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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_pmsg_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_pmsg_2eproto;
namespace proto {
class ADVDeviceIdentity;
struct ADVDeviceIdentityDefaultTypeInternal;
extern ADVDeviceIdentityDefaultTypeInternal _ADVDeviceIdentity_default_instance_;
class ADVKeyIndexList;
struct ADVKeyIndexListDefaultTypeInternal;
extern ADVKeyIndexListDefaultTypeInternal _ADVKeyIndexList_default_instance_;
class ADVSignedDeviceIdentity;
struct ADVSignedDeviceIdentityDefaultTypeInternal;
extern ADVSignedDeviceIdentityDefaultTypeInternal _ADVSignedDeviceIdentity_default_instance_;
class ADVSignedDeviceIdentityHMAC;
struct ADVSignedDeviceIdentityHMACDefaultTypeInternal;
extern ADVSignedDeviceIdentityHMACDefaultTypeInternal _ADVSignedDeviceIdentityHMAC_default_instance_;
class ADVSignedKeyIndexList;
struct ADVSignedKeyIndexListDefaultTypeInternal;
extern ADVSignedKeyIndexListDefaultTypeInternal _ADVSignedKeyIndexList_default_instance_;
class ActionLink;
struct ActionLinkDefaultTypeInternal;
extern ActionLinkDefaultTypeInternal _ActionLink_default_instance_;
class AutoDownloadSettings;
struct AutoDownloadSettingsDefaultTypeInternal;
extern AutoDownloadSettingsDefaultTypeInternal _AutoDownloadSettings_default_instance_;
class BizAccountLinkInfo;
struct BizAccountLinkInfoDefaultTypeInternal;
extern BizAccountLinkInfoDefaultTypeInternal _BizAccountLinkInfo_default_instance_;
class BizAccountPayload;
struct BizAccountPayloadDefaultTypeInternal;
extern BizAccountPayloadDefaultTypeInternal _BizAccountPayload_default_instance_;
class BizIdentityInfo;
struct BizIdentityInfoDefaultTypeInternal;
extern BizIdentityInfoDefaultTypeInternal _BizIdentityInfo_default_instance_;
class CertChain;
struct CertChainDefaultTypeInternal;
extern CertChainDefaultTypeInternal _CertChain_default_instance_;
class CertChain_NoiseCertificate;
struct CertChain_NoiseCertificateDefaultTypeInternal;
extern CertChain_NoiseCertificateDefaultTypeInternal _CertChain_NoiseCertificate_default_instance_;
class CertChain_NoiseCertificate_Details;
struct CertChain_NoiseCertificate_DetailsDefaultTypeInternal;
extern CertChain_NoiseCertificate_DetailsDefaultTypeInternal _CertChain_NoiseCertificate_Details_default_instance_;
class Chain;
struct ChainDefaultTypeInternal;
extern ChainDefaultTypeInternal _Chain_default_instance_;
class ChainKey;
struct ChainKeyDefaultTypeInternal;
extern ChainKeyDefaultTypeInternal _ChainKey_default_instance_;
class ClientPayload;
struct ClientPayloadDefaultTypeInternal;
extern ClientPayloadDefaultTypeInternal _ClientPayload_default_instance_;
class ClientPayload_DNSSource;
struct ClientPayload_DNSSourceDefaultTypeInternal;
extern ClientPayload_DNSSourceDefaultTypeInternal _ClientPayload_DNSSource_default_instance_;
class ClientPayload_DevicePairingRegistrationData;
struct ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal;
extern ClientPayload_DevicePairingRegistrationDataDefaultTypeInternal _ClientPayload_DevicePairingRegistrationData_default_instance_;
class ClientPayload_UserAgent;
struct ClientPayload_UserAgentDefaultTypeInternal;
extern ClientPayload_UserAgentDefaultTypeInternal _ClientPayload_UserAgent_default_instance_;
class ClientPayload_UserAgent_AppVersion;
struct ClientPayload_UserAgent_AppVersionDefaultTypeInternal;
extern ClientPayload_UserAgent_AppVersionDefaultTypeInternal _ClientPayload_UserAgent_AppVersion_default_instance_;
class ClientPayload_WebInfo;
struct ClientPayload_WebInfoDefaultTypeInternal;
extern ClientPayload_WebInfoDefaultTypeInternal _ClientPayload_WebInfo_default_instance_;
class ClientPayload_WebInfo_WebdPayload;
struct ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal;
extern ClientPayload_WebInfo_WebdPayloadDefaultTypeInternal _ClientPayload_WebInfo_WebdPayload_default_instance_;
class ContextInfo;
struct ContextInfoDefaultTypeInternal;
extern ContextInfoDefaultTypeInternal _ContextInfo_default_instance_;
class ContextInfo_AdReplyInfo;
struct ContextInfo_AdReplyInfoDefaultTypeInternal;
extern ContextInfo_AdReplyInfoDefaultTypeInternal _ContextInfo_AdReplyInfo_default_instance_;
class ContextInfo_ExternalAdReplyInfo;
struct ContextInfo_ExternalAdReplyInfoDefaultTypeInternal;
extern ContextInfo_ExternalAdReplyInfoDefaultTypeInternal _ContextInfo_ExternalAdReplyInfo_default_instance_;
class Conversation;
struct ConversationDefaultTypeInternal;
extern ConversationDefaultTypeInternal _Conversation_default_instance_;
class DeviceListMetadata;
struct DeviceListMetadataDefaultTypeInternal;
extern DeviceListMetadataDefaultTypeInternal _DeviceListMetadata_default_instance_;
class DeviceProps;
struct DevicePropsDefaultTypeInternal;
extern DevicePropsDefaultTypeInternal _DeviceProps_default_instance_;
class DeviceProps_AppVersion;
struct DeviceProps_AppVersionDefaultTypeInternal;
extern DeviceProps_AppVersionDefaultTypeInternal _DeviceProps_AppVersion_default_instance_;
class DisappearingMode;
struct DisappearingModeDefaultTypeInternal;
extern DisappearingModeDefaultTypeInternal _DisappearingMode_default_instance_;
class EphemeralSetting;
struct EphemeralSettingDefaultTypeInternal;
extern EphemeralSettingDefaultTypeInternal _EphemeralSetting_default_instance_;
class ExitCode;
struct ExitCodeDefaultTypeInternal;
extern ExitCodeDefaultTypeInternal _ExitCode_default_instance_;
class ExternalBlobReference;
struct ExternalBlobReferenceDefaultTypeInternal;
extern ExternalBlobReferenceDefaultTypeInternal _ExternalBlobReference_default_instance_;
class GlobalSettings;
struct GlobalSettingsDefaultTypeInternal;
extern GlobalSettingsDefaultTypeInternal _GlobalSettings_default_instance_;
class GroupParticipant;
struct GroupParticipantDefaultTypeInternal;
extern GroupParticipantDefaultTypeInternal _GroupParticipant_default_instance_;
class HandshakeMessage;
struct HandshakeMessageDefaultTypeInternal;
extern HandshakeMessageDefaultTypeInternal _HandshakeMessage_default_instance_;
class HandshakeMessage_ClientFinish;
struct HandshakeMessage_ClientFinishDefaultTypeInternal;
extern HandshakeMessage_ClientFinishDefaultTypeInternal _HandshakeMessage_ClientFinish_default_instance_;
class HandshakeMessage_ClientHello;
struct HandshakeMessage_ClientHelloDefaultTypeInternal;
extern HandshakeMessage_ClientHelloDefaultTypeInternal _HandshakeMessage_ClientHello_default_instance_;
class HandshakeMessage_ServerHello;
struct HandshakeMessage_ServerHelloDefaultTypeInternal;
extern HandshakeMessage_ServerHelloDefaultTypeInternal _HandshakeMessage_ServerHello_default_instance_;
class HistorySync;
struct HistorySyncDefaultTypeInternal;
extern HistorySyncDefaultTypeInternal _HistorySync_default_instance_;
class HistorySyncMsg;
struct HistorySyncMsgDefaultTypeInternal;
extern HistorySyncMsgDefaultTypeInternal _HistorySyncMsg_default_instance_;
class HydratedTemplateButton;
struct HydratedTemplateButtonDefaultTypeInternal;
extern HydratedTemplateButtonDefaultTypeInternal _HydratedTemplateButton_default_instance_;
class HydratedTemplateButton_HydratedCallButton;
struct HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal;
extern HydratedTemplateButton_HydratedCallButtonDefaultTypeInternal _HydratedTemplateButton_HydratedCallButton_default_instance_;
class HydratedTemplateButton_HydratedQuickReplyButton;
struct HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal;
extern HydratedTemplateButton_HydratedQuickReplyButtonDefaultTypeInternal _HydratedTemplateButton_HydratedQuickReplyButton_default_instance_;
class HydratedTemplateButton_HydratedURLButton;
struct HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal;
extern HydratedTemplateButton_HydratedURLButtonDefaultTypeInternal _HydratedTemplateButton_HydratedURLButton_default_instance_;
class IdentityKeyPairStructure;
struct IdentityKeyPairStructureDefaultTypeInternal;
extern IdentityKeyPairStructureDefaultTypeInternal _IdentityKeyPairStructure_default_instance_;
class InteractiveAnnotation;
struct InteractiveAnnotationDefaultTypeInternal;
extern InteractiveAnnotationDefaultTypeInternal _InteractiveAnnotation_default_instance_;
class KeepInChat;
struct KeepInChatDefaultTypeInternal;
extern KeepInChatDefaultTypeInternal _KeepInChat_default_instance_;
class KeyId;
struct KeyIdDefaultTypeInternal;
extern KeyIdDefaultTypeInternal _KeyId_default_instance_;
class LocalizedName;
struct LocalizedNameDefaultTypeInternal;
extern LocalizedNameDefaultTypeInternal _LocalizedName_default_instance_;
class Location;
struct LocationDefaultTypeInternal;
extern LocationDefaultTypeInternal _Location_default_instance_;
class MediaData;
struct MediaDataDefaultTypeInternal;
extern MediaDataDefaultTypeInternal _MediaData_default_instance_;
class MediaRetryNotification;
struct MediaRetryNotificationDefaultTypeInternal;
extern MediaRetryNotificationDefaultTypeInternal _MediaRetryNotification_default_instance_;
class Message;
struct MessageDefaultTypeInternal;
extern MessageDefaultTypeInternal _Message_default_instance_;
class MessageContextInfo;
struct MessageContextInfoDefaultTypeInternal;
extern MessageContextInfoDefaultTypeInternal _MessageContextInfo_default_instance_;
class MessageKey;
struct MessageKeyDefaultTypeInternal;
extern MessageKeyDefaultTypeInternal _MessageKey_default_instance_;
class Message_AppStateFatalExceptionNotification;
struct Message_AppStateFatalExceptionNotificationDefaultTypeInternal;
extern Message_AppStateFatalExceptionNotificationDefaultTypeInternal _Message_AppStateFatalExceptionNotification_default_instance_;
class Message_AppStateSyncKey;
struct Message_AppStateSyncKeyDefaultTypeInternal;
extern Message_AppStateSyncKeyDefaultTypeInternal _Message_AppStateSyncKey_default_instance_;
class Message_AppStateSyncKeyData;
struct Message_AppStateSyncKeyDataDefaultTypeInternal;
extern Message_AppStateSyncKeyDataDefaultTypeInternal _Message_AppStateSyncKeyData_default_instance_;
class Message_AppStateSyncKeyFingerprint;
struct Message_AppStateSyncKeyFingerprintDefaultTypeInternal;
extern Message_AppStateSyncKeyFingerprintDefaultTypeInternal _Message_AppStateSyncKeyFingerprint_default_instance_;
class Message_AppStateSyncKeyId;
struct Message_AppStateSyncKeyIdDefaultTypeInternal;
extern Message_AppStateSyncKeyIdDefaultTypeInternal _Message_AppStateSyncKeyId_default_instance_;
class Message_AppStateSyncKeyRequest;
struct Message_AppStateSyncKeyRequestDefaultTypeInternal;
extern Message_AppStateSyncKeyRequestDefaultTypeInternal _Message_AppStateSyncKeyRequest_default_instance_;
class Message_AppStateSyncKeyShare;
struct Message_AppStateSyncKeyShareDefaultTypeInternal;
extern Message_AppStateSyncKeyShareDefaultTypeInternal _Message_AppStateSyncKeyShare_default_instance_;
class Message_AudioMessage;
struct Message_AudioMessageDefaultTypeInternal;
extern Message_AudioMessageDefaultTypeInternal _Message_AudioMessage_default_instance_;
class Message_ButtonsMessage;
struct Message_ButtonsMessageDefaultTypeInternal;
extern Message_ButtonsMessageDefaultTypeInternal _Message_ButtonsMessage_default_instance_;
class Message_ButtonsMessage_Button;
struct Message_ButtonsMessage_ButtonDefaultTypeInternal;
extern Message_ButtonsMessage_ButtonDefaultTypeInternal _Message_ButtonsMessage_Button_default_instance_;
class Message_ButtonsMessage_Button_ButtonText;
struct Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal;
extern Message_ButtonsMessage_Button_ButtonTextDefaultTypeInternal _Message_ButtonsMessage_Button_ButtonText_default_instance_;
class Message_ButtonsMessage_Button_NativeFlowInfo;
struct Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal;
extern Message_ButtonsMessage_Button_NativeFlowInfoDefaultTypeInternal _Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_;
class Message_ButtonsResponseMessage;
struct Message_ButtonsResponseMessageDefaultTypeInternal;
extern Message_ButtonsResponseMessageDefaultTypeInternal _Message_ButtonsResponseMessage_default_instance_;
class Message_Call;
struct Message_CallDefaultTypeInternal;
extern Message_CallDefaultTypeInternal _Message_Call_default_instance_;
class Message_CancelPaymentRequestMessage;
struct Message_CancelPaymentRequestMessageDefaultTypeInternal;
extern Message_CancelPaymentRequestMessageDefaultTypeInternal _Message_CancelPaymentRequestMessage_default_instance_;
class Message_Chat;
struct Message_ChatDefaultTypeInternal;
extern Message_ChatDefaultTypeInternal _Message_Chat_default_instance_;
class Message_ContactMessage;
struct Message_ContactMessageDefaultTypeInternal;
extern Message_ContactMessageDefaultTypeInternal _Message_ContactMessage_default_instance_;
class Message_ContactsArrayMessage;
struct Message_ContactsArrayMessageDefaultTypeInternal;
extern Message_ContactsArrayMessageDefaultTypeInternal _Message_ContactsArrayMessage_default_instance_;
class Message_DeclinePaymentRequestMessage;
struct Message_DeclinePaymentRequestMessageDefaultTypeInternal;
extern Message_DeclinePaymentRequestMessageDefaultTypeInternal _Message_DeclinePaymentRequestMessage_default_instance_;
class Message_DeviceSentMessage;
struct Message_DeviceSentMessageDefaultTypeInternal;
extern Message_DeviceSentMessageDefaultTypeInternal _Message_DeviceSentMessage_default_instance_;
class Message_DocumentMessage;
struct Message_DocumentMessageDefaultTypeInternal;
extern Message_DocumentMessageDefaultTypeInternal _Message_DocumentMessage_default_instance_;
class Message_ExtendedTextMessage;
struct Message_ExtendedTextMessageDefaultTypeInternal;
extern Message_ExtendedTextMessageDefaultTypeInternal _Message_ExtendedTextMessage_default_instance_;
class Message_FutureProofMessage;
struct Message_FutureProofMessageDefaultTypeInternal;
extern Message_FutureProofMessageDefaultTypeInternal _Message_FutureProofMessage_default_instance_;
class Message_GroupInviteMessage;
struct Message_GroupInviteMessageDefaultTypeInternal;
extern Message_GroupInviteMessageDefaultTypeInternal _Message_GroupInviteMessage_default_instance_;
class Message_HighlyStructuredMessage;
struct Message_HighlyStructuredMessageDefaultTypeInternal;
extern Message_HighlyStructuredMessageDefaultTypeInternal _Message_HighlyStructuredMessage_default_instance_;
class Message_HighlyStructuredMessage_HSMLocalizableParameter;
struct Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal;
extern Message_HighlyStructuredMessage_HSMLocalizableParameterDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_;
class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency;
struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal;
extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrencyDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_;
class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime;
struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal;
extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTimeDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_;
class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent;
struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal;
extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponentDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_;
class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch;
struct Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal;
extern Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpochDefaultTypeInternal _Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_;
class Message_HistorySyncNotification;
struct Message_HistorySyncNotificationDefaultTypeInternal;
extern Message_HistorySyncNotificationDefaultTypeInternal _Message_HistorySyncNotification_default_instance_;
class Message_ImageMessage;
struct Message_ImageMessageDefaultTypeInternal;
extern Message_ImageMessageDefaultTypeInternal _Message_ImageMessage_default_instance_;
class Message_InitialSecurityNotificationSettingSync;
struct Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal;
extern Message_InitialSecurityNotificationSettingSyncDefaultTypeInternal _Message_InitialSecurityNotificationSettingSync_default_instance_;
class Message_InteractiveMessage;
struct Message_InteractiveMessageDefaultTypeInternal;
extern Message_InteractiveMessageDefaultTypeInternal _Message_InteractiveMessage_default_instance_;
class Message_InteractiveMessage_Body;
struct Message_InteractiveMessage_BodyDefaultTypeInternal;
extern Message_InteractiveMessage_BodyDefaultTypeInternal _Message_InteractiveMessage_Body_default_instance_;
class Message_InteractiveMessage_CollectionMessage;
struct Message_InteractiveMessage_CollectionMessageDefaultTypeInternal;
extern Message_InteractiveMessage_CollectionMessageDefaultTypeInternal _Message_InteractiveMessage_CollectionMessage_default_instance_;
class Message_InteractiveMessage_Footer;
struct Message_InteractiveMessage_FooterDefaultTypeInternal;
extern Message_InteractiveMessage_FooterDefaultTypeInternal _Message_InteractiveMessage_Footer_default_instance_;
class Message_InteractiveMessage_Header;
struct Message_InteractiveMessage_HeaderDefaultTypeInternal;
extern Message_InteractiveMessage_HeaderDefaultTypeInternal _Message_InteractiveMessage_Header_default_instance_;
class Message_InteractiveMessage_NativeFlowMessage;
struct Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal;
extern Message_InteractiveMessage_NativeFlowMessageDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_default_instance_;
class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton;
struct Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal;
extern Message_InteractiveMessage_NativeFlowMessage_NativeFlowButtonDefaultTypeInternal _Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_;
class Message_InteractiveMessage_ShopMessage;
struct Message_InteractiveMessage_ShopMessageDefaultTypeInternal;
extern Message_InteractiveMessage_ShopMessageDefaultTypeInternal _Message_InteractiveMessage_ShopMessage_default_instance_;
class Message_InteractiveResponseMessage;
struct Message_InteractiveResponseMessageDefaultTypeInternal;
extern Message_InteractiveResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_default_instance_;
class Message_InteractiveResponseMessage_Body;
struct Message_InteractiveResponseMessage_BodyDefaultTypeInternal;
extern Message_InteractiveResponseMessage_BodyDefaultTypeInternal _Message_InteractiveResponseMessage_Body_default_instance_;
class Message_InteractiveResponseMessage_NativeFlowResponseMessage;
struct Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal;
extern Message_InteractiveResponseMessage_NativeFlowResponseMessageDefaultTypeInternal _Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_;
class Message_InvoiceMessage;
struct Message_InvoiceMessageDefaultTypeInternal;
extern Message_InvoiceMessageDefaultTypeInternal _Message_InvoiceMessage_default_instance_;
class Message_KeepInChatMessage;
struct Message_KeepInChatMessageDefaultTypeInternal;
extern Message_KeepInChatMessageDefaultTypeInternal _Message_KeepInChatMessage_default_instance_;
class Message_ListMessage;
struct Message_ListMessageDefaultTypeInternal;
extern Message_ListMessageDefaultTypeInternal _Message_ListMessage_default_instance_;
class Message_ListMessage_Product;
struct Message_ListMessage_ProductDefaultTypeInternal;
extern Message_ListMessage_ProductDefaultTypeInternal _Message_ListMessage_Product_default_instance_;
class Message_ListMessage_ProductListHeaderImage;
struct Message_ListMessage_ProductListHeaderImageDefaultTypeInternal;
extern Message_ListMessage_ProductListHeaderImageDefaultTypeInternal _Message_ListMessage_ProductListHeaderImage_default_instance_;
class Message_ListMessage_ProductListInfo;
struct Message_ListMessage_ProductListInfoDefaultTypeInternal;
extern Message_ListMessage_ProductListInfoDefaultTypeInternal _Message_ListMessage_ProductListInfo_default_instance_;
class Message_ListMessage_ProductSection;
struct Message_ListMessage_ProductSectionDefaultTypeInternal;
extern Message_ListMessage_ProductSectionDefaultTypeInternal _Message_ListMessage_ProductSection_default_instance_;
class Message_ListMessage_Row;
struct Message_ListMessage_RowDefaultTypeInternal;
extern Message_ListMessage_RowDefaultTypeInternal _Message_ListMessage_Row_default_instance_;
class Message_ListMessage_Section;
struct Message_ListMessage_SectionDefaultTypeInternal;
extern Message_ListMessage_SectionDefaultTypeInternal _Message_ListMessage_Section_default_instance_;
class Message_ListResponseMessage;
struct Message_ListResponseMessageDefaultTypeInternal;
extern Message_ListResponseMessageDefaultTypeInternal _Message_ListResponseMessage_default_instance_;
class Message_ListResponseMessage_SingleSelectReply;
struct Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal;
extern Message_ListResponseMessage_SingleSelectReplyDefaultTypeInternal _Message_ListResponseMessage_SingleSelectReply_default_instance_;
class Message_LiveLocationMessage;
struct Message_LiveLocationMessageDefaultTypeInternal;
extern Message_LiveLocationMessageDefaultTypeInternal _Message_LiveLocationMessage_default_instance_;
class Message_LocationMessage;
struct Message_LocationMessageDefaultTypeInternal;
extern Message_LocationMessageDefaultTypeInternal _Message_LocationMessage_default_instance_;
class Message_OrderMessage;
struct Message_OrderMessageDefaultTypeInternal;
extern Message_OrderMessageDefaultTypeInternal _Message_OrderMessage_default_instance_;
class Message_PaymentInviteMessage;
struct Message_PaymentInviteMessageDefaultTypeInternal;
extern Message_PaymentInviteMessageDefaultTypeInternal _Message_PaymentInviteMessage_default_instance_;
class Message_PollCreationMessage;
struct Message_PollCreationMessageDefaultTypeInternal;
extern Message_PollCreationMessageDefaultTypeInternal _Message_PollCreationMessage_default_instance_;
class Message_PollCreationMessage_Option;
struct Message_PollCreationMessage_OptionDefaultTypeInternal;
extern Message_PollCreationMessage_OptionDefaultTypeInternal _Message_PollCreationMessage_Option_default_instance_;
class Message_PollEncValue;
struct Message_PollEncValueDefaultTypeInternal;
extern Message_PollEncValueDefaultTypeInternal _Message_PollEncValue_default_instance_;
class Message_PollUpdateMessage;
struct Message_PollUpdateMessageDefaultTypeInternal;
extern Message_PollUpdateMessageDefaultTypeInternal _Message_PollUpdateMessage_default_instance_;
class Message_PollUpdateMessageMetadata;
struct Message_PollUpdateMessageMetadataDefaultTypeInternal;
extern Message_PollUpdateMessageMetadataDefaultTypeInternal _Message_PollUpdateMessageMetadata_default_instance_;
class Message_PollVoteMessage;
struct Message_PollVoteMessageDefaultTypeInternal;
extern Message_PollVoteMessageDefaultTypeInternal _Message_PollVoteMessage_default_instance_;
class Message_ProductMessage;
struct Message_ProductMessageDefaultTypeInternal;
extern Message_ProductMessageDefaultTypeInternal _Message_ProductMessage_default_instance_;
class Message_ProductMessage_CatalogSnapshot;
struct Message_ProductMessage_CatalogSnapshotDefaultTypeInternal;
extern Message_ProductMessage_CatalogSnapshotDefaultTypeInternal _Message_ProductMessage_CatalogSnapshot_default_instance_;
class Message_ProductMessage_ProductSnapshot;
struct Message_ProductMessage_ProductSnapshotDefaultTypeInternal;
extern Message_ProductMessage_ProductSnapshotDefaultTypeInternal _Message_ProductMessage_ProductSnapshot_default_instance_;
class Message_ProtocolMessage;
struct Message_ProtocolMessageDefaultTypeInternal;
extern Message_ProtocolMessageDefaultTypeInternal _Message_ProtocolMessage_default_instance_;
class Message_ReactionMessage;
struct Message_ReactionMessageDefaultTypeInternal;
extern Message_ReactionMessageDefaultTypeInternal _Message_ReactionMessage_default_instance_;
class Message_RequestMediaUploadMessage;
struct Message_RequestMediaUploadMessageDefaultTypeInternal;
extern Message_RequestMediaUploadMessageDefaultTypeInternal _Message_RequestMediaUploadMessage_default_instance_;
class Message_RequestMediaUploadResponseMessage;
struct Message_RequestMediaUploadResponseMessageDefaultTypeInternal;
extern Message_RequestMediaUploadResponseMessageDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_default_instance_;
class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult;
struct Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal;
extern Message_RequestMediaUploadResponseMessage_RequestMediaUploadResultDefaultTypeInternal _Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_;
class Message_RequestPaymentMessage;
struct Message_RequestPaymentMessageDefaultTypeInternal;
extern Message_RequestPaymentMessageDefaultTypeInternal _Message_RequestPaymentMessage_default_instance_;
class Message_RequestPhoneNumberMessage;
struct Message_RequestPhoneNumberMessageDefaultTypeInternal;
extern Message_RequestPhoneNumberMessageDefaultTypeInternal _Message_RequestPhoneNumberMessage_default_instance_;
class Message_SendPaymentMessage;
struct Message_SendPaymentMessageDefaultTypeInternal;
extern Message_SendPaymentMessageDefaultTypeInternal _Message_SendPaymentMessage_default_instance_;
class Message_SenderKeyDistributionMessage;
struct Message_SenderKeyDistributionMessageDefaultTypeInternal;
extern Message_SenderKeyDistributionMessageDefaultTypeInternal _Message_SenderKeyDistributionMessage_default_instance_;
class Message_StickerMessage;
struct Message_StickerMessageDefaultTypeInternal;
extern Message_StickerMessageDefaultTypeInternal _Message_StickerMessage_default_instance_;
class Message_StickerSyncRMRMessage;
struct Message_StickerSyncRMRMessageDefaultTypeInternal;
extern Message_StickerSyncRMRMessageDefaultTypeInternal _Message_StickerSyncRMRMessage_default_instance_;
class Message_TemplateButtonReplyMessage;
struct Message_TemplateButtonReplyMessageDefaultTypeInternal;
extern Message_TemplateButtonReplyMessageDefaultTypeInternal _Message_TemplateButtonReplyMessage_default_instance_;
class Message_TemplateMessage;
struct Message_TemplateMessageDefaultTypeInternal;
extern Message_TemplateMessageDefaultTypeInternal _Message_TemplateMessage_default_instance_;
class Message_TemplateMessage_FourRowTemplate;
struct Message_TemplateMessage_FourRowTemplateDefaultTypeInternal;
extern Message_TemplateMessage_FourRowTemplateDefaultTypeInternal _Message_TemplateMessage_FourRowTemplate_default_instance_;
class Message_TemplateMessage_HydratedFourRowTemplate;
struct Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal;
extern Message_TemplateMessage_HydratedFourRowTemplateDefaultTypeInternal _Message_TemplateMessage_HydratedFourRowTemplate_default_instance_;
class Message_VideoMessage;
struct Message_VideoMessageDefaultTypeInternal;
extern Message_VideoMessageDefaultTypeInternal _Message_VideoMessage_default_instance_;
class Money;
struct MoneyDefaultTypeInternal;
extern MoneyDefaultTypeInternal _Money_default_instance_;
class MsgOpaqueData;
struct MsgOpaqueDataDefaultTypeInternal;
extern MsgOpaqueDataDefaultTypeInternal _MsgOpaqueData_default_instance_;
class MsgOpaqueData_PollOption;
struct MsgOpaqueData_PollOptionDefaultTypeInternal;
extern MsgOpaqueData_PollOptionDefaultTypeInternal _MsgOpaqueData_PollOption_default_instance_;
class MsgRowOpaqueData;
struct MsgRowOpaqueDataDefaultTypeInternal;
extern MsgRowOpaqueDataDefaultTypeInternal _MsgRowOpaqueData_default_instance_;
class NoiseCertificate;
struct NoiseCertificateDefaultTypeInternal;
extern NoiseCertificateDefaultTypeInternal _NoiseCertificate_default_instance_;
class NoiseCertificate_Details;
struct NoiseCertificate_DetailsDefaultTypeInternal;
extern NoiseCertificate_DetailsDefaultTypeInternal _NoiseCertificate_Details_default_instance_;
class NotificationMessageInfo;
struct NotificationMessageInfoDefaultTypeInternal;
extern NotificationMessageInfoDefaultTypeInternal _NotificationMessageInfo_default_instance_;
class PastParticipant;
struct PastParticipantDefaultTypeInternal;
extern PastParticipantDefaultTypeInternal _PastParticipant_default_instance_;
class PastParticipants;
struct PastParticipantsDefaultTypeInternal;
extern PastParticipantsDefaultTypeInternal _PastParticipants_default_instance_;
class PaymentBackground;
struct PaymentBackgroundDefaultTypeInternal;
extern PaymentBackgroundDefaultTypeInternal _PaymentBackground_default_instance_;
class PaymentBackground_MediaData;
struct PaymentBackground_MediaDataDefaultTypeInternal;
extern PaymentBackground_MediaDataDefaultTypeInternal _PaymentBackground_MediaData_default_instance_;
class PaymentInfo;
struct PaymentInfoDefaultTypeInternal;
extern PaymentInfoDefaultTypeInternal _PaymentInfo_default_instance_;
class PendingKeyExchange;
struct PendingKeyExchangeDefaultTypeInternal;
extern PendingKeyExchangeDefaultTypeInternal _PendingKeyExchange_default_instance_;
class PendingPreKey;
struct PendingPreKeyDefaultTypeInternal;
extern PendingPreKeyDefaultTypeInternal _PendingPreKey_default_instance_;
class PhotoChange;
struct PhotoChangeDefaultTypeInternal;
extern PhotoChangeDefaultTypeInternal _PhotoChange_default_instance_;
class Point;
struct PointDefaultTypeInternal;
extern PointDefaultTypeInternal _Point_default_instance_;
class PollAdditionalMetadata;
struct PollAdditionalMetadataDefaultTypeInternal;
extern PollAdditionalMetadataDefaultTypeInternal _PollAdditionalMetadata_default_instance_;
class PollEncValue;
struct PollEncValueDefaultTypeInternal;
extern PollEncValueDefaultTypeInternal _PollEncValue_default_instance_;
class PollUpdate;
struct PollUpdateDefaultTypeInternal;
extern PollUpdateDefaultTypeInternal _PollUpdate_default_instance_;
class PreKeyRecordStructure;
struct PreKeyRecordStructureDefaultTypeInternal;
extern PreKeyRecordStructureDefaultTypeInternal _PreKeyRecordStructure_default_instance_;
class Pushname;
struct PushnameDefaultTypeInternal;
extern PushnameDefaultTypeInternal _Pushname_default_instance_;
class Reaction;
struct ReactionDefaultTypeInternal;
extern ReactionDefaultTypeInternal _Reaction_default_instance_;
class RecentEmojiWeight;
struct RecentEmojiWeightDefaultTypeInternal;
extern RecentEmojiWeightDefaultTypeInternal _RecentEmojiWeight_default_instance_;
class RecordStructure;
struct RecordStructureDefaultTypeInternal;
extern RecordStructureDefaultTypeInternal _RecordStructure_default_instance_;
class SenderChainKey;
struct SenderChainKeyDefaultTypeInternal;
extern SenderChainKeyDefaultTypeInternal _SenderChainKey_default_instance_;
class SenderKeyRecordStructure;
struct SenderKeyRecordStructureDefaultTypeInternal;
extern SenderKeyRecordStructureDefaultTypeInternal _SenderKeyRecordStructure_default_instance_;
class SenderKeyStateStructure;
struct SenderKeyStateStructureDefaultTypeInternal;
extern SenderKeyStateStructureDefaultTypeInternal _SenderKeyStateStructure_default_instance_;
class SenderMessageKey;
struct SenderMessageKeyDefaultTypeInternal;
extern SenderMessageKeyDefaultTypeInternal _SenderMessageKey_default_instance_;
class SenderSigningKey;
struct SenderSigningKeyDefaultTypeInternal;
extern SenderSigningKeyDefaultTypeInternal _SenderSigningKey_default_instance_;
class ServerErrorReceipt;
struct ServerErrorReceiptDefaultTypeInternal;
extern ServerErrorReceiptDefaultTypeInternal _ServerErrorReceipt_default_instance_;
class SessionStructure;
struct SessionStructureDefaultTypeInternal;
extern SessionStructureDefaultTypeInternal _SessionStructure_default_instance_;
class SignedPreKeyRecordStructure;
struct SignedPreKeyRecordStructureDefaultTypeInternal;
extern SignedPreKeyRecordStructureDefaultTypeInternal _SignedPreKeyRecordStructure_default_instance_;
class StatusPSA;
struct StatusPSADefaultTypeInternal;
extern StatusPSADefaultTypeInternal _StatusPSA_default_instance_;
class StickerMetadata;
struct StickerMetadataDefaultTypeInternal;
extern StickerMetadataDefaultTypeInternal _StickerMetadata_default_instance_;
class SyncActionData;
struct SyncActionDataDefaultTypeInternal;
extern SyncActionDataDefaultTypeInternal _SyncActionData_default_instance_;
class SyncActionValue;
struct SyncActionValueDefaultTypeInternal;
extern SyncActionValueDefaultTypeInternal _SyncActionValue_default_instance_;
class SyncActionValue_AgentAction;
struct SyncActionValue_AgentActionDefaultTypeInternal;
extern SyncActionValue_AgentActionDefaultTypeInternal _SyncActionValue_AgentAction_default_instance_;
class SyncActionValue_AndroidUnsupportedActions;
struct SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal;
extern SyncActionValue_AndroidUnsupportedActionsDefaultTypeInternal _SyncActionValue_AndroidUnsupportedActions_default_instance_;
class SyncActionValue_ArchiveChatAction;
struct SyncActionValue_ArchiveChatActionDefaultTypeInternal;
extern SyncActionValue_ArchiveChatActionDefaultTypeInternal _SyncActionValue_ArchiveChatAction_default_instance_;
class SyncActionValue_ClearChatAction;
struct SyncActionValue_ClearChatActionDefaultTypeInternal;
extern SyncActionValue_ClearChatActionDefaultTypeInternal _SyncActionValue_ClearChatAction_default_instance_;
class SyncActionValue_ContactAction;
struct SyncActionValue_ContactActionDefaultTypeInternal;
extern SyncActionValue_ContactActionDefaultTypeInternal _SyncActionValue_ContactAction_default_instance_;
class SyncActionValue_DeleteChatAction;
struct SyncActionValue_DeleteChatActionDefaultTypeInternal;
extern SyncActionValue_DeleteChatActionDefaultTypeInternal _SyncActionValue_DeleteChatAction_default_instance_;
class SyncActionValue_DeleteMessageForMeAction;
struct SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal;
extern SyncActionValue_DeleteMessageForMeActionDefaultTypeInternal _SyncActionValue_DeleteMessageForMeAction_default_instance_;
class SyncActionValue_KeyExpiration;
struct SyncActionValue_KeyExpirationDefaultTypeInternal;
extern SyncActionValue_KeyExpirationDefaultTypeInternal _SyncActionValue_KeyExpiration_default_instance_;
class SyncActionValue_LabelAssociationAction;
struct SyncActionValue_LabelAssociationActionDefaultTypeInternal;
extern SyncActionValue_LabelAssociationActionDefaultTypeInternal _SyncActionValue_LabelAssociationAction_default_instance_;
class SyncActionValue_LabelEditAction;
struct SyncActionValue_LabelEditActionDefaultTypeInternal;
extern SyncActionValue_LabelEditActionDefaultTypeInternal _SyncActionValue_LabelEditAction_default_instance_;
class SyncActionValue_LocaleSetting;
struct SyncActionValue_LocaleSettingDefaultTypeInternal;
extern SyncActionValue_LocaleSettingDefaultTypeInternal _SyncActionValue_LocaleSetting_default_instance_;
class SyncActionValue_MarkChatAsReadAction;
struct SyncActionValue_MarkChatAsReadActionDefaultTypeInternal;
extern SyncActionValue_MarkChatAsReadActionDefaultTypeInternal _SyncActionValue_MarkChatAsReadAction_default_instance_;
class SyncActionValue_MuteAction;
struct SyncActionValue_MuteActionDefaultTypeInternal;
extern SyncActionValue_MuteActionDefaultTypeInternal _SyncActionValue_MuteAction_default_instance_;
class SyncActionValue_NuxAction;
struct SyncActionValue_NuxActionDefaultTypeInternal;
extern SyncActionValue_NuxActionDefaultTypeInternal _SyncActionValue_NuxAction_default_instance_;
class SyncActionValue_PinAction;
struct SyncActionValue_PinActionDefaultTypeInternal;
extern SyncActionValue_PinActionDefaultTypeInternal _SyncActionValue_PinAction_default_instance_;
class SyncActionValue_PrimaryFeature;
struct SyncActionValue_PrimaryFeatureDefaultTypeInternal;
extern SyncActionValue_PrimaryFeatureDefaultTypeInternal _SyncActionValue_PrimaryFeature_default_instance_;
class SyncActionValue_PrimaryVersionAction;
struct SyncActionValue_PrimaryVersionActionDefaultTypeInternal;
extern SyncActionValue_PrimaryVersionActionDefaultTypeInternal _SyncActionValue_PrimaryVersionAction_default_instance_;
class SyncActionValue_PushNameSetting;
struct SyncActionValue_PushNameSettingDefaultTypeInternal;
extern SyncActionValue_PushNameSettingDefaultTypeInternal _SyncActionValue_PushNameSetting_default_instance_;
class SyncActionValue_QuickReplyAction;
struct SyncActionValue_QuickReplyActionDefaultTypeInternal;
extern SyncActionValue_QuickReplyActionDefaultTypeInternal _SyncActionValue_QuickReplyAction_default_instance_;
class SyncActionValue_RecentEmojiWeightsAction;
struct SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal;
extern SyncActionValue_RecentEmojiWeightsActionDefaultTypeInternal _SyncActionValue_RecentEmojiWeightsAction_default_instance_;
class SyncActionValue_SecurityNotificationSetting;
struct SyncActionValue_SecurityNotificationSettingDefaultTypeInternal;
extern SyncActionValue_SecurityNotificationSettingDefaultTypeInternal _SyncActionValue_SecurityNotificationSetting_default_instance_;
class SyncActionValue_StarAction;
struct SyncActionValue_StarActionDefaultTypeInternal;
extern SyncActionValue_StarActionDefaultTypeInternal _SyncActionValue_StarAction_default_instance_;
class SyncActionValue_StickerAction;
struct SyncActionValue_StickerActionDefaultTypeInternal;
extern SyncActionValue_StickerActionDefaultTypeInternal _SyncActionValue_StickerAction_default_instance_;
class SyncActionValue_SubscriptionAction;
struct SyncActionValue_SubscriptionActionDefaultTypeInternal;
extern SyncActionValue_SubscriptionActionDefaultTypeInternal _SyncActionValue_SubscriptionAction_default_instance_;
class SyncActionValue_SyncActionMessage;
struct SyncActionValue_SyncActionMessageDefaultTypeInternal;
extern SyncActionValue_SyncActionMessageDefaultTypeInternal _SyncActionValue_SyncActionMessage_default_instance_;
class SyncActionValue_SyncActionMessageRange;
struct SyncActionValue_SyncActionMessageRangeDefaultTypeInternal;
extern SyncActionValue_SyncActionMessageRangeDefaultTypeInternal _SyncActionValue_SyncActionMessageRange_default_instance_;
class SyncActionValue_TimeFormatAction;
struct SyncActionValue_TimeFormatActionDefaultTypeInternal;
extern SyncActionValue_TimeFormatActionDefaultTypeInternal _SyncActionValue_TimeFormatAction_default_instance_;
class SyncActionValue_UnarchiveChatsSetting;
struct SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal;
extern SyncActionValue_UnarchiveChatsSettingDefaultTypeInternal _SyncActionValue_UnarchiveChatsSetting_default_instance_;
class SyncActionValue_UserStatusMuteAction;
struct SyncActionValue_UserStatusMuteActionDefaultTypeInternal;
extern SyncActionValue_UserStatusMuteActionDefaultTypeInternal _SyncActionValue_UserStatusMuteAction_default_instance_;
class SyncdIndex;
struct SyncdIndexDefaultTypeInternal;
extern SyncdIndexDefaultTypeInternal _SyncdIndex_default_instance_;
class SyncdMutation;
struct SyncdMutationDefaultTypeInternal;
extern SyncdMutationDefaultTypeInternal _SyncdMutation_default_instance_;
class SyncdMutations;
struct SyncdMutationsDefaultTypeInternal;
extern SyncdMutationsDefaultTypeInternal _SyncdMutations_default_instance_;
class SyncdPatch;
struct SyncdPatchDefaultTypeInternal;
extern SyncdPatchDefaultTypeInternal _SyncdPatch_default_instance_;
class SyncdRecord;
struct SyncdRecordDefaultTypeInternal;
extern SyncdRecordDefaultTypeInternal _SyncdRecord_default_instance_;
class SyncdSnapshot;
struct SyncdSnapshotDefaultTypeInternal;
extern SyncdSnapshotDefaultTypeInternal _SyncdSnapshot_default_instance_;
class SyncdValue;
struct SyncdValueDefaultTypeInternal;
extern SyncdValueDefaultTypeInternal _SyncdValue_default_instance_;
class SyncdVersion;
struct SyncdVersionDefaultTypeInternal;
extern SyncdVersionDefaultTypeInternal _SyncdVersion_default_instance_;
class TemplateButton;
struct TemplateButtonDefaultTypeInternal;
extern TemplateButtonDefaultTypeInternal _TemplateButton_default_instance_;
class TemplateButton_CallButton;
struct TemplateButton_CallButtonDefaultTypeInternal;
extern TemplateButton_CallButtonDefaultTypeInternal _TemplateButton_CallButton_default_instance_;
class TemplateButton_QuickReplyButton;
struct TemplateButton_QuickReplyButtonDefaultTypeInternal;
extern TemplateButton_QuickReplyButtonDefaultTypeInternal _TemplateButton_QuickReplyButton_default_instance_;
class TemplateButton_URLButton;
struct TemplateButton_URLButtonDefaultTypeInternal;
extern TemplateButton_URLButtonDefaultTypeInternal _TemplateButton_URLButton_default_instance_;
class UserReceipt;
struct UserReceiptDefaultTypeInternal;
extern UserReceiptDefaultTypeInternal _UserReceipt_default_instance_;
class VerifiedNameCertificate;
struct VerifiedNameCertificateDefaultTypeInternal;
extern VerifiedNameCertificateDefaultTypeInternal _VerifiedNameCertificate_default_instance_;
class VerifiedNameCertificate_Details;
struct VerifiedNameCertificate_DetailsDefaultTypeInternal;
extern VerifiedNameCertificate_DetailsDefaultTypeInternal _VerifiedNameCertificate_Details_default_instance_;
class WallpaperSettings;
struct WallpaperSettingsDefaultTypeInternal;
extern WallpaperSettingsDefaultTypeInternal _WallpaperSettings_default_instance_;
class WebFeatures;
struct WebFeaturesDefaultTypeInternal;
extern WebFeaturesDefaultTypeInternal _WebFeatures_default_instance_;
class WebMessageInfo;
struct WebMessageInfoDefaultTypeInternal;
extern WebMessageInfoDefaultTypeInternal _WebMessageInfo_default_instance_;
class WebNotificationsInfo;
struct WebNotificationsInfoDefaultTypeInternal;
extern WebNotificationsInfoDefaultTypeInternal _WebNotificationsInfo_default_instance_;
}  // namespace proto
PROTOBUF_NAMESPACE_OPEN
template<> ::proto::ADVDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVDeviceIdentity>(Arena*);
template<> ::proto::ADVKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVKeyIndexList>(Arena*);
template<> ::proto::ADVSignedDeviceIdentity* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentity>(Arena*);
template<> ::proto::ADVSignedDeviceIdentityHMAC* Arena::CreateMaybeMessage<::proto::ADVSignedDeviceIdentityHMAC>(Arena*);
template<> ::proto::ADVSignedKeyIndexList* Arena::CreateMaybeMessage<::proto::ADVSignedKeyIndexList>(Arena*);
template<> ::proto::ActionLink* Arena::CreateMaybeMessage<::proto::ActionLink>(Arena*);
template<> ::proto::AutoDownloadSettings* Arena::CreateMaybeMessage<::proto::AutoDownloadSettings>(Arena*);
template<> ::proto::BizAccountLinkInfo* Arena::CreateMaybeMessage<::proto::BizAccountLinkInfo>(Arena*);
template<> ::proto::BizAccountPayload* Arena::CreateMaybeMessage<::proto::BizAccountPayload>(Arena*);
template<> ::proto::BizIdentityInfo* Arena::CreateMaybeMessage<::proto::BizIdentityInfo>(Arena*);
template<> ::proto::CertChain* Arena::CreateMaybeMessage<::proto::CertChain>(Arena*);
template<> ::proto::CertChain_NoiseCertificate* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(Arena*);
template<> ::proto::CertChain_NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::CertChain_NoiseCertificate_Details>(Arena*);
template<> ::proto::Chain* Arena::CreateMaybeMessage<::proto::Chain>(Arena*);
template<> ::proto::ChainKey* Arena::CreateMaybeMessage<::proto::ChainKey>(Arena*);
template<> ::proto::ClientPayload* Arena::CreateMaybeMessage<::proto::ClientPayload>(Arena*);
template<> ::proto::ClientPayload_DNSSource* Arena::CreateMaybeMessage<::proto::ClientPayload_DNSSource>(Arena*);
template<> ::proto::ClientPayload_DevicePairingRegistrationData* Arena::CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(Arena*);
template<> ::proto::ClientPayload_UserAgent* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent>(Arena*);
template<> ::proto::ClientPayload_UserAgent_AppVersion* Arena::CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(Arena*);
template<> ::proto::ClientPayload_WebInfo* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo>(Arena*);
template<> ::proto::ClientPayload_WebInfo_WebdPayload* Arena::CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(Arena*);
template<> ::proto::ContextInfo* Arena::CreateMaybeMessage<::proto::ContextInfo>(Arena*);
template<> ::proto::ContextInfo_AdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(Arena*);
template<> ::proto::ContextInfo_ExternalAdReplyInfo* Arena::CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(Arena*);
template<> ::proto::Conversation* Arena::CreateMaybeMessage<::proto::Conversation>(Arena*);
template<> ::proto::DeviceListMetadata* Arena::CreateMaybeMessage<::proto::DeviceListMetadata>(Arena*);
template<> ::proto::DeviceProps* Arena::CreateMaybeMessage<::proto::DeviceProps>(Arena*);
template<> ::proto::DeviceProps_AppVersion* Arena::CreateMaybeMessage<::proto::DeviceProps_AppVersion>(Arena*);
template<> ::proto::DisappearingMode* Arena::CreateMaybeMessage<::proto::DisappearingMode>(Arena*);
template<> ::proto::EphemeralSetting* Arena::CreateMaybeMessage<::proto::EphemeralSetting>(Arena*);
template<> ::proto::ExitCode* Arena::CreateMaybeMessage<::proto::ExitCode>(Arena*);
template<> ::proto::ExternalBlobReference* Arena::CreateMaybeMessage<::proto::ExternalBlobReference>(Arena*);
template<> ::proto::GlobalSettings* Arena::CreateMaybeMessage<::proto::GlobalSettings>(Arena*);
template<> ::proto::GroupParticipant* Arena::CreateMaybeMessage<::proto::GroupParticipant>(Arena*);
template<> ::proto::HandshakeMessage* Arena::CreateMaybeMessage<::proto::HandshakeMessage>(Arena*);
template<> ::proto::HandshakeMessage_ClientFinish* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(Arena*);
template<> ::proto::HandshakeMessage_ClientHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(Arena*);
template<> ::proto::HandshakeMessage_ServerHello* Arena::CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(Arena*);
template<> ::proto::HistorySync* Arena::CreateMaybeMessage<::proto::HistorySync>(Arena*);
template<> ::proto::HistorySyncMsg* Arena::CreateMaybeMessage<::proto::HistorySyncMsg>(Arena*);
template<> ::proto::HydratedTemplateButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton>(Arena*);
template<> ::proto::HydratedTemplateButton_HydratedCallButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedCallButton>(Arena*);
template<> ::proto::HydratedTemplateButton_HydratedQuickReplyButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedQuickReplyButton>(Arena*);
template<> ::proto::HydratedTemplateButton_HydratedURLButton* Arena::CreateMaybeMessage<::proto::HydratedTemplateButton_HydratedURLButton>(Arena*);
template<> ::proto::IdentityKeyPairStructure* Arena::CreateMaybeMessage<::proto::IdentityKeyPairStructure>(Arena*);
template<> ::proto::InteractiveAnnotation* Arena::CreateMaybeMessage<::proto::InteractiveAnnotation>(Arena*);
template<> ::proto::KeepInChat* Arena::CreateMaybeMessage<::proto::KeepInChat>(Arena*);
template<> ::proto::KeyId* Arena::CreateMaybeMessage<::proto::KeyId>(Arena*);
template<> ::proto::LocalizedName* Arena::CreateMaybeMessage<::proto::LocalizedName>(Arena*);
template<> ::proto::Location* Arena::CreateMaybeMessage<::proto::Location>(Arena*);
template<> ::proto::MediaData* Arena::CreateMaybeMessage<::proto::MediaData>(Arena*);
template<> ::proto::MediaRetryNotification* Arena::CreateMaybeMessage<::proto::MediaRetryNotification>(Arena*);
template<> ::proto::Message* Arena::CreateMaybeMessage<::proto::Message>(Arena*);
template<> ::proto::MessageContextInfo* Arena::CreateMaybeMessage<::proto::MessageContextInfo>(Arena*);
template<> ::proto::MessageKey* Arena::CreateMaybeMessage<::proto::MessageKey>(Arena*);
template<> ::proto::Message_AppStateFatalExceptionNotification* Arena::CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(Arena*);
template<> ::proto::Message_AppStateSyncKey* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKey>(Arena*);
template<> ::proto::Message_AppStateSyncKeyData* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(Arena*);
template<> ::proto::Message_AppStateSyncKeyFingerprint* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(Arena*);
template<> ::proto::Message_AppStateSyncKeyId* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(Arena*);
template<> ::proto::Message_AppStateSyncKeyRequest* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(Arena*);
template<> ::proto::Message_AppStateSyncKeyShare* Arena::CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(Arena*);
template<> ::proto::Message_AudioMessage* Arena::CreateMaybeMessage<::proto::Message_AudioMessage>(Arena*);
template<> ::proto::Message_ButtonsMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage>(Arena*);
template<> ::proto::Message_ButtonsMessage_Button* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button>(Arena*);
template<> ::proto::Message_ButtonsMessage_Button_ButtonText* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(Arena*);
template<> ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Arena::CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(Arena*);
template<> ::proto::Message_ButtonsResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(Arena*);
template<> ::proto::Message_Call* Arena::CreateMaybeMessage<::proto::Message_Call>(Arena*);
template<> ::proto::Message_CancelPaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(Arena*);
template<> ::proto::Message_Chat* Arena::CreateMaybeMessage<::proto::Message_Chat>(Arena*);
template<> ::proto::Message_ContactMessage* Arena::CreateMaybeMessage<::proto::Message_ContactMessage>(Arena*);
template<> ::proto::Message_ContactsArrayMessage* Arena::CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(Arena*);
template<> ::proto::Message_DeclinePaymentRequestMessage* Arena::CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(Arena*);
template<> ::proto::Message_DeviceSentMessage* Arena::CreateMaybeMessage<::proto::Message_DeviceSentMessage>(Arena*);
template<> ::proto::Message_DocumentMessage* Arena::CreateMaybeMessage<::proto::Message_DocumentMessage>(Arena*);
template<> ::proto::Message_ExtendedTextMessage* Arena::CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(Arena*);
template<> ::proto::Message_FutureProofMessage* Arena::CreateMaybeMessage<::proto::Message_FutureProofMessage>(Arena*);
template<> ::proto::Message_GroupInviteMessage* Arena::CreateMaybeMessage<::proto::Message_GroupInviteMessage>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(Arena*);
template<> ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Arena::CreateMaybeMessage<::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(Arena*);
template<> ::proto::Message_HistorySyncNotification* Arena::CreateMaybeMessage<::proto::Message_HistorySyncNotification>(Arena*);
template<> ::proto::Message_ImageMessage* Arena::CreateMaybeMessage<::proto::Message_ImageMessage>(Arena*);
template<> ::proto::Message_InitialSecurityNotificationSettingSync* Arena::CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(Arena*);
template<> ::proto::Message_InteractiveMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage>(Arena*);
template<> ::proto::Message_InteractiveMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(Arena*);
template<> ::proto::Message_InteractiveMessage_CollectionMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_CollectionMessage>(Arena*);
template<> ::proto::Message_InteractiveMessage_Footer* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(Arena*);
template<> ::proto::Message_InteractiveMessage_Header* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(Arena*);
template<> ::proto::Message_InteractiveMessage_NativeFlowMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage>(Arena*);
template<> ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(Arena*);
template<> ::proto::Message_InteractiveMessage_ShopMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveMessage_ShopMessage>(Arena*);
template<> ::proto::Message_InteractiveResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(Arena*);
template<> ::proto::Message_InteractiveResponseMessage_Body* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(Arena*);
template<> ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Arena::CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage>(Arena*);
template<> ::proto::Message_InvoiceMessage* Arena::CreateMaybeMessage<::proto::Message_InvoiceMessage>(Arena*);
template<> ::proto::Message_KeepInChatMessage* Arena::CreateMaybeMessage<::proto::Message_KeepInChatMessage>(Arena*);
template<> ::proto::Message_ListMessage* Arena::CreateMaybeMessage<::proto::Message_ListMessage>(Arena*);
template<> ::proto::Message_ListMessage_Product* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Product>(Arena*);
template<> ::proto::Message_ListMessage_ProductListHeaderImage* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(Arena*);
template<> ::proto::Message_ListMessage_ProductListInfo* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(Arena*);
template<> ::proto::Message_ListMessage_ProductSection* Arena::CreateMaybeMessage<::proto::Message_ListMessage_ProductSection>(Arena*);
template<> ::proto::Message_ListMessage_Row* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Row>(Arena*);
template<> ::proto::Message_ListMessage_Section* Arena::CreateMaybeMessage<::proto::Message_ListMessage_Section>(Arena*);
template<> ::proto::Message_ListResponseMessage* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage>(Arena*);
template<> ::proto::Message_ListResponseMessage_SingleSelectReply* Arena::CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(Arena*);
template<> ::proto::Message_LiveLocationMessage* Arena::CreateMaybeMessage<::proto::Message_LiveLocationMessage>(Arena*);
template<> ::proto::Message_LocationMessage* Arena::CreateMaybeMessage<::proto::Message_LocationMessage>(Arena*);
template<> ::proto::Message_OrderMessage* Arena::CreateMaybeMessage<::proto::Message_OrderMessage>(Arena*);
template<> ::proto::Message_PaymentInviteMessage* Arena::CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(Arena*);
template<> ::proto::Message_PollCreationMessage* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage>(Arena*);
template<> ::proto::Message_PollCreationMessage_Option* Arena::CreateMaybeMessage<::proto::Message_PollCreationMessage_Option>(Arena*);
template<> ::proto::Message_PollEncValue* Arena::CreateMaybeMessage<::proto::Message_PollEncValue>(Arena*);
template<> ::proto::Message_PollUpdateMessage* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessage>(Arena*);
template<> ::proto::Message_PollUpdateMessageMetadata* Arena::CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(Arena*);
template<> ::proto::Message_PollVoteMessage* Arena::CreateMaybeMessage<::proto::Message_PollVoteMessage>(Arena*);
template<> ::proto::Message_ProductMessage* Arena::CreateMaybeMessage<::proto::Message_ProductMessage>(Arena*);
template<> ::proto::Message_ProductMessage_CatalogSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(Arena*);
template<> ::proto::Message_ProductMessage_ProductSnapshot* Arena::CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(Arena*);
template<> ::proto::Message_ProtocolMessage* Arena::CreateMaybeMessage<::proto::Message_ProtocolMessage>(Arena*);
template<> ::proto::Message_ReactionMessage* Arena::CreateMaybeMessage<::proto::Message_ReactionMessage>(Arena*);
template<> ::proto::Message_RequestMediaUploadMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(Arena*);
template<> ::proto::Message_RequestMediaUploadResponseMessage* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(Arena*);
template<> ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Arena::CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(Arena*);
template<> ::proto::Message_RequestPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(Arena*);
template<> ::proto::Message_RequestPhoneNumberMessage* Arena::CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(Arena*);
template<> ::proto::Message_SendPaymentMessage* Arena::CreateMaybeMessage<::proto::Message_SendPaymentMessage>(Arena*);
template<> ::proto::Message_SenderKeyDistributionMessage* Arena::CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(Arena*);
template<> ::proto::Message_StickerMessage* Arena::CreateMaybeMessage<::proto::Message_StickerMessage>(Arena*);
template<> ::proto::Message_StickerSyncRMRMessage* Arena::CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(Arena*);
template<> ::proto::Message_TemplateButtonReplyMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(Arena*);
template<> ::proto::Message_TemplateMessage* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage>(Arena*);
template<> ::proto::Message_TemplateMessage_FourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_FourRowTemplate>(Arena*);
template<> ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Arena::CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(Arena*);
template<> ::proto::Message_VideoMessage* Arena::CreateMaybeMessage<::proto::Message_VideoMessage>(Arena*);
template<> ::proto::Money* Arena::CreateMaybeMessage<::proto::Money>(Arena*);
template<> ::proto::MsgOpaqueData* Arena::CreateMaybeMessage<::proto::MsgOpaqueData>(Arena*);
template<> ::proto::MsgOpaqueData_PollOption* Arena::CreateMaybeMessage<::proto::MsgOpaqueData_PollOption>(Arena*);
template<> ::proto::MsgRowOpaqueData* Arena::CreateMaybeMessage<::proto::MsgRowOpaqueData>(Arena*);
template<> ::proto::NoiseCertificate* Arena::CreateMaybeMessage<::proto::NoiseCertificate>(Arena*);
template<> ::proto::NoiseCertificate_Details* Arena::CreateMaybeMessage<::proto::NoiseCertificate_Details>(Arena*);
template<> ::proto::NotificationMessageInfo* Arena::CreateMaybeMessage<::proto::NotificationMessageInfo>(Arena*);
template<> ::proto::PastParticipant* Arena::CreateMaybeMessage<::proto::PastParticipant>(Arena*);
template<> ::proto::PastParticipants* Arena::CreateMaybeMessage<::proto::PastParticipants>(Arena*);
template<> ::proto::PaymentBackground* Arena::CreateMaybeMessage<::proto::PaymentBackground>(Arena*);
template<> ::proto::PaymentBackground_MediaData* Arena::CreateMaybeMessage<::proto::PaymentBackground_MediaData>(Arena*);
template<> ::proto::PaymentInfo* Arena::CreateMaybeMessage<::proto::PaymentInfo>(Arena*);
template<> ::proto::PendingKeyExchange* Arena::CreateMaybeMessage<::proto::PendingKeyExchange>(Arena*);
template<> ::proto::PendingPreKey* Arena::CreateMaybeMessage<::proto::PendingPreKey>(Arena*);
template<> ::proto::PhotoChange* Arena::CreateMaybeMessage<::proto::PhotoChange>(Arena*);
template<> ::proto::Point* Arena::CreateMaybeMessage<::proto::Point>(Arena*);
template<> ::proto::PollAdditionalMetadata* Arena::CreateMaybeMessage<::proto::PollAdditionalMetadata>(Arena*);
template<> ::proto::PollEncValue* Arena::CreateMaybeMessage<::proto::PollEncValue>(Arena*);
template<> ::proto::PollUpdate* Arena::CreateMaybeMessage<::proto::PollUpdate>(Arena*);
template<> ::proto::PreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::PreKeyRecordStructure>(Arena*);
template<> ::proto::Pushname* Arena::CreateMaybeMessage<::proto::Pushname>(Arena*);
template<> ::proto::Reaction* Arena::CreateMaybeMessage<::proto::Reaction>(Arena*);
template<> ::proto::RecentEmojiWeight* Arena::CreateMaybeMessage<::proto::RecentEmojiWeight>(Arena*);
template<> ::proto::RecordStructure* Arena::CreateMaybeMessage<::proto::RecordStructure>(Arena*);
template<> ::proto::SenderChainKey* Arena::CreateMaybeMessage<::proto::SenderChainKey>(Arena*);
template<> ::proto::SenderKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SenderKeyRecordStructure>(Arena*);
template<> ::proto::SenderKeyStateStructure* Arena::CreateMaybeMessage<::proto::SenderKeyStateStructure>(Arena*);
template<> ::proto::SenderMessageKey* Arena::CreateMaybeMessage<::proto::SenderMessageKey>(Arena*);
template<> ::proto::SenderSigningKey* Arena::CreateMaybeMessage<::proto::SenderSigningKey>(Arena*);
template<> ::proto::ServerErrorReceipt* Arena::CreateMaybeMessage<::proto::ServerErrorReceipt>(Arena*);
template<> ::proto::SessionStructure* Arena::CreateMaybeMessage<::proto::SessionStructure>(Arena*);
template<> ::proto::SignedPreKeyRecordStructure* Arena::CreateMaybeMessage<::proto::SignedPreKeyRecordStructure>(Arena*);
template<> ::proto::StatusPSA* Arena::CreateMaybeMessage<::proto::StatusPSA>(Arena*);
template<> ::proto::StickerMetadata* Arena::CreateMaybeMessage<::proto::StickerMetadata>(Arena*);
template<> ::proto::SyncActionData* Arena::CreateMaybeMessage<::proto::SyncActionData>(Arena*);
template<> ::proto::SyncActionValue* Arena::CreateMaybeMessage<::proto::SyncActionValue>(Arena*);
template<> ::proto::SyncActionValue_AgentAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(Arena*);
template<> ::proto::SyncActionValue_AndroidUnsupportedActions* Arena::CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(Arena*);
template<> ::proto::SyncActionValue_ArchiveChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(Arena*);
template<> ::proto::SyncActionValue_ClearChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(Arena*);
template<> ::proto::SyncActionValue_ContactAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(Arena*);
template<> ::proto::SyncActionValue_DeleteChatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(Arena*);
template<> ::proto::SyncActionValue_DeleteMessageForMeAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(Arena*);
template<> ::proto::SyncActionValue_KeyExpiration* Arena::CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(Arena*);
template<> ::proto::SyncActionValue_LabelAssociationAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(Arena*);
template<> ::proto::SyncActionValue_LabelEditAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(Arena*);
template<> ::proto::SyncActionValue_LocaleSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(Arena*);
template<> ::proto::SyncActionValue_MarkChatAsReadAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(Arena*);
template<> ::proto::SyncActionValue_MuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(Arena*);
template<> ::proto::SyncActionValue_NuxAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(Arena*);
template<> ::proto::SyncActionValue_PinAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PinAction>(Arena*);
template<> ::proto::SyncActionValue_PrimaryFeature* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(Arena*);
template<> ::proto::SyncActionValue_PrimaryVersionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(Arena*);
template<> ::proto::SyncActionValue_PushNameSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(Arena*);
template<> ::proto::SyncActionValue_QuickReplyAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(Arena*);
template<> ::proto::SyncActionValue_RecentEmojiWeightsAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(Arena*);
template<> ::proto::SyncActionValue_SecurityNotificationSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(Arena*);
template<> ::proto::SyncActionValue_StarAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StarAction>(Arena*);
template<> ::proto::SyncActionValue_StickerAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(Arena*);
template<> ::proto::SyncActionValue_SubscriptionAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(Arena*);
template<> ::proto::SyncActionValue_SyncActionMessage* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessage>(Arena*);
template<> ::proto::SyncActionValue_SyncActionMessageRange* Arena::CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(Arena*);
template<> ::proto::SyncActionValue_TimeFormatAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(Arena*);
template<> ::proto::SyncActionValue_UnarchiveChatsSetting* Arena::CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(Arena*);
template<> ::proto::SyncActionValue_UserStatusMuteAction* Arena::CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(Arena*);
template<> ::proto::SyncdIndex* Arena::CreateMaybeMessage<::proto::SyncdIndex>(Arena*);
template<> ::proto::SyncdMutation* Arena::CreateMaybeMessage<::proto::SyncdMutation>(Arena*);
template<> ::proto::SyncdMutations* Arena::CreateMaybeMessage<::proto::SyncdMutations>(Arena*);
template<> ::proto::SyncdPatch* Arena::CreateMaybeMessage<::proto::SyncdPatch>(Arena*);
template<> ::proto::SyncdRecord* Arena::CreateMaybeMessage<::proto::SyncdRecord>(Arena*);
template<> ::proto::SyncdSnapshot* Arena::CreateMaybeMessage<::proto::SyncdSnapshot>(Arena*);
template<> ::proto::SyncdValue* Arena::CreateMaybeMessage<::proto::SyncdValue>(Arena*);
template<> ::proto::SyncdVersion* Arena::CreateMaybeMessage<::proto::SyncdVersion>(Arena*);
template<> ::proto::TemplateButton* Arena::CreateMaybeMessage<::proto::TemplateButton>(Arena*);
template<> ::proto::TemplateButton_CallButton* Arena::CreateMaybeMessage<::proto::TemplateButton_CallButton>(Arena*);
template<> ::proto::TemplateButton_QuickReplyButton* Arena::CreateMaybeMessage<::proto::TemplateButton_QuickReplyButton>(Arena*);
template<> ::proto::TemplateButton_URLButton* Arena::CreateMaybeMessage<::proto::TemplateButton_URLButton>(Arena*);
template<> ::proto::UserReceipt* Arena::CreateMaybeMessage<::proto::UserReceipt>(Arena*);
template<> ::proto::VerifiedNameCertificate* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate>(Arena*);
template<> ::proto::VerifiedNameCertificate_Details* Arena::CreateMaybeMessage<::proto::VerifiedNameCertificate_Details>(Arena*);
template<> ::proto::WallpaperSettings* Arena::CreateMaybeMessage<::proto::WallpaperSettings>(Arena*);
template<> ::proto::WebFeatures* Arena::CreateMaybeMessage<::proto::WebFeatures>(Arena*);
template<> ::proto::WebMessageInfo* Arena::CreateMaybeMessage<::proto::WebMessageInfo>(Arena*);
template<> ::proto::WebNotificationsInfo* Arena::CreateMaybeMessage<::proto::WebNotificationsInfo>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace proto {

enum BizAccountLinkInfo_AccountType : int {
  BizAccountLinkInfo_AccountType_ENTERPRISE = 0
};
bool BizAccountLinkInfo_AccountType_IsValid(int value);
constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MIN = BizAccountLinkInfo_AccountType_ENTERPRISE;
constexpr BizAccountLinkInfo_AccountType BizAccountLinkInfo_AccountType_AccountType_MAX = BizAccountLinkInfo_AccountType_ENTERPRISE;
constexpr int BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE = BizAccountLinkInfo_AccountType_AccountType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_AccountType_descriptor();
template<typename T>
inline const std::string& BizAccountLinkInfo_AccountType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BizAccountLinkInfo_AccountType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BizAccountLinkInfo_AccountType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BizAccountLinkInfo_AccountType_descriptor(), enum_t_value);
}
inline bool BizAccountLinkInfo_AccountType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_AccountType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizAccountLinkInfo_AccountType>(
    BizAccountLinkInfo_AccountType_descriptor(), name, value);
}
enum BizAccountLinkInfo_HostStorageType : int {
  BizAccountLinkInfo_HostStorageType_ON_PREMISE = 0,
  BizAccountLinkInfo_HostStorageType_FACEBOOK = 1
};
bool BizAccountLinkInfo_HostStorageType_IsValid(int value);
constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MIN = BizAccountLinkInfo_HostStorageType_ON_PREMISE;
constexpr BizAccountLinkInfo_HostStorageType BizAccountLinkInfo_HostStorageType_HostStorageType_MAX = BizAccountLinkInfo_HostStorageType_FACEBOOK;
constexpr int BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizAccountLinkInfo_HostStorageType_HostStorageType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizAccountLinkInfo_HostStorageType_descriptor();
template<typename T>
inline const std::string& BizAccountLinkInfo_HostStorageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BizAccountLinkInfo_HostStorageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BizAccountLinkInfo_HostStorageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BizAccountLinkInfo_HostStorageType_descriptor(), enum_t_value);
}
inline bool BizAccountLinkInfo_HostStorageType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizAccountLinkInfo_HostStorageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizAccountLinkInfo_HostStorageType>(
    BizAccountLinkInfo_HostStorageType_descriptor(), name, value);
}
enum BizIdentityInfo_ActualActorsType : int {
  BizIdentityInfo_ActualActorsType_SELF = 0,
  BizIdentityInfo_ActualActorsType_BSP = 1
};
bool BizIdentityInfo_ActualActorsType_IsValid(int value);
constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MIN = BizIdentityInfo_ActualActorsType_SELF;
constexpr BizIdentityInfo_ActualActorsType BizIdentityInfo_ActualActorsType_ActualActorsType_MAX = BizIdentityInfo_ActualActorsType_BSP;
constexpr int BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE = BizIdentityInfo_ActualActorsType_ActualActorsType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_ActualActorsType_descriptor();
template<typename T>
inline const std::string& BizIdentityInfo_ActualActorsType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BizIdentityInfo_ActualActorsType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BizIdentityInfo_ActualActorsType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BizIdentityInfo_ActualActorsType_descriptor(), enum_t_value);
}
inline bool BizIdentityInfo_ActualActorsType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_ActualActorsType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_ActualActorsType>(
    BizIdentityInfo_ActualActorsType_descriptor(), name, value);
}
enum BizIdentityInfo_HostStorageType : int {
  BizIdentityInfo_HostStorageType_ON_PREMISE = 0,
  BizIdentityInfo_HostStorageType_FACEBOOK = 1
};
bool BizIdentityInfo_HostStorageType_IsValid(int value);
constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MIN = BizIdentityInfo_HostStorageType_ON_PREMISE;
constexpr BizIdentityInfo_HostStorageType BizIdentityInfo_HostStorageType_HostStorageType_MAX = BizIdentityInfo_HostStorageType_FACEBOOK;
constexpr int BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE = BizIdentityInfo_HostStorageType_HostStorageType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_HostStorageType_descriptor();
template<typename T>
inline const std::string& BizIdentityInfo_HostStorageType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BizIdentityInfo_HostStorageType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BizIdentityInfo_HostStorageType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BizIdentityInfo_HostStorageType_descriptor(), enum_t_value);
}
inline bool BizIdentityInfo_HostStorageType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_HostStorageType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_HostStorageType>(
    BizIdentityInfo_HostStorageType_descriptor(), name, value);
}
enum BizIdentityInfo_VerifiedLevelValue : int {
  BizIdentityInfo_VerifiedLevelValue_UNKNOWN = 0,
  BizIdentityInfo_VerifiedLevelValue_LOW = 1,
  BizIdentityInfo_VerifiedLevelValue_HIGH = 2
};
bool BizIdentityInfo_VerifiedLevelValue_IsValid(int value);
constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN = BizIdentityInfo_VerifiedLevelValue_UNKNOWN;
constexpr BizIdentityInfo_VerifiedLevelValue BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX = BizIdentityInfo_VerifiedLevelValue_HIGH;
constexpr int BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE = BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BizIdentityInfo_VerifiedLevelValue_descriptor();
template<typename T>
inline const std::string& BizIdentityInfo_VerifiedLevelValue_Name(T enum_t_value) {
  static_assert(::std::is_same<T, BizIdentityInfo_VerifiedLevelValue>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function BizIdentityInfo_VerifiedLevelValue_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    BizIdentityInfo_VerifiedLevelValue_descriptor(), enum_t_value);
}
inline bool BizIdentityInfo_VerifiedLevelValue_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BizIdentityInfo_VerifiedLevelValue* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BizIdentityInfo_VerifiedLevelValue>(
    BizIdentityInfo_VerifiedLevelValue_descriptor(), name, value);
}
enum ClientPayload_DNSSource_DNSResolutionMethod : int {
  ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM = 0,
  ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE = 1,
  ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED = 2,
  ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE = 3,
  ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK = 4
};
bool ClientPayload_DNSSource_DNSResolutionMethod_IsValid(int value);
constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN = ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM;
constexpr ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX = ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK;
constexpr int ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE = ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
template<typename T>
inline const std::string& ClientPayload_DNSSource_DNSResolutionMethod_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_DNSSource_DNSResolutionMethod>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_DNSSource_DNSResolutionMethod_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), enum_t_value);
}
inline bool ClientPayload_DNSSource_DNSResolutionMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_DNSSource_DNSResolutionMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_DNSSource_DNSResolutionMethod>(
    ClientPayload_DNSSource_DNSResolutionMethod_descriptor(), name, value);
}
enum ClientPayload_UserAgent_Platform : int {
  ClientPayload_UserAgent_Platform_ANDROID = 0,
  ClientPayload_UserAgent_Platform_IOS = 1,
  ClientPayload_UserAgent_Platform_WINDOWS_PHONE = 2,
  ClientPayload_UserAgent_Platform_BLACKBERRY = 3,
  ClientPayload_UserAgent_Platform_BLACKBERRYX = 4,
  ClientPayload_UserAgent_Platform_S40 = 5,
  ClientPayload_UserAgent_Platform_S60 = 6,
  ClientPayload_UserAgent_Platform_PYTHON_CLIENT = 7,
  ClientPayload_UserAgent_Platform_TIZEN = 8,
  ClientPayload_UserAgent_Platform_ENTERPRISE = 9,
  ClientPayload_UserAgent_Platform_SMB_ANDROID = 10,
  ClientPayload_UserAgent_Platform_KAIOS = 11,
  ClientPayload_UserAgent_Platform_SMB_IOS = 12,
  ClientPayload_UserAgent_Platform_WINDOWS = 13,
  ClientPayload_UserAgent_Platform_WEB = 14,
  ClientPayload_UserAgent_Platform_PORTAL = 15,
  ClientPayload_UserAgent_Platform_GREEN_ANDROID = 16,
  ClientPayload_UserAgent_Platform_GREEN_IPHONE = 17,
  ClientPayload_UserAgent_Platform_BLUE_ANDROID = 18,
  ClientPayload_UserAgent_Platform_BLUE_IPHONE = 19,
  ClientPayload_UserAgent_Platform_FBLITE_ANDROID = 20,
  ClientPayload_UserAgent_Platform_MLITE_ANDROID = 21,
  ClientPayload_UserAgent_Platform_IGLITE_ANDROID = 22,
  ClientPayload_UserAgent_Platform_PAGE = 23,
  ClientPayload_UserAgent_Platform_MACOS = 24,
  ClientPayload_UserAgent_Platform_OCULUS_MSG = 25,
  ClientPayload_UserAgent_Platform_OCULUS_CALL = 26,
  ClientPayload_UserAgent_Platform_MILAN = 27,
  ClientPayload_UserAgent_Platform_CAPI = 28
};
bool ClientPayload_UserAgent_Platform_IsValid(int value);
constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MIN = ClientPayload_UserAgent_Platform_ANDROID;
constexpr ClientPayload_UserAgent_Platform ClientPayload_UserAgent_Platform_Platform_MAX = ClientPayload_UserAgent_Platform_CAPI;
constexpr int ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE = ClientPayload_UserAgent_Platform_Platform_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_Platform_descriptor();
template<typename T>
inline const std::string& ClientPayload_UserAgent_Platform_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_UserAgent_Platform>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_UserAgent_Platform_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_UserAgent_Platform_descriptor(), enum_t_value);
}
inline bool ClientPayload_UserAgent_Platform_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_Platform* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_UserAgent_Platform>(
    ClientPayload_UserAgent_Platform_descriptor(), name, value);
}
enum ClientPayload_UserAgent_ReleaseChannel : int {
  ClientPayload_UserAgent_ReleaseChannel_RELEASE = 0,
  ClientPayload_UserAgent_ReleaseChannel_BETA = 1,
  ClientPayload_UserAgent_ReleaseChannel_ALPHA = 2,
  ClientPayload_UserAgent_ReleaseChannel_DEBUG = 3
};
bool ClientPayload_UserAgent_ReleaseChannel_IsValid(int value);
constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN = ClientPayload_UserAgent_ReleaseChannel_RELEASE;
constexpr ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX = ClientPayload_UserAgent_ReleaseChannel_DEBUG;
constexpr int ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE = ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_UserAgent_ReleaseChannel_descriptor();
template<typename T>
inline const std::string& ClientPayload_UserAgent_ReleaseChannel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_UserAgent_ReleaseChannel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_UserAgent_ReleaseChannel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_UserAgent_ReleaseChannel_descriptor(), enum_t_value);
}
inline bool ClientPayload_UserAgent_ReleaseChannel_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_UserAgent_ReleaseChannel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_UserAgent_ReleaseChannel>(
    ClientPayload_UserAgent_ReleaseChannel_descriptor(), name, value);
}
enum ClientPayload_WebInfo_WebSubPlatform : int {
  ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER = 0,
  ClientPayload_WebInfo_WebSubPlatform_APP_STORE = 1,
  ClientPayload_WebInfo_WebSubPlatform_WIN_STORE = 2,
  ClientPayload_WebInfo_WebSubPlatform_DARWIN = 3,
  ClientPayload_WebInfo_WebSubPlatform_WINDA = 4
};
bool ClientPayload_WebInfo_WebSubPlatform_IsValid(int value);
constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN = ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER;
constexpr ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX = ClientPayload_WebInfo_WebSubPlatform_WINDA;
constexpr int ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE = ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_WebInfo_WebSubPlatform_descriptor();
template<typename T>
inline const std::string& ClientPayload_WebInfo_WebSubPlatform_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_WebInfo_WebSubPlatform>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_WebInfo_WebSubPlatform_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_WebInfo_WebSubPlatform_descriptor(), enum_t_value);
}
inline bool ClientPayload_WebInfo_WebSubPlatform_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_WebInfo_WebSubPlatform* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_WebInfo_WebSubPlatform>(
    ClientPayload_WebInfo_WebSubPlatform_descriptor(), name, value);
}
enum ClientPayload_ConnectReason : int {
  ClientPayload_ConnectReason_PUSH = 0,
  ClientPayload_ConnectReason_USER_ACTIVATED = 1,
  ClientPayload_ConnectReason_SCHEDULED = 2,
  ClientPayload_ConnectReason_ERROR_RECONNECT = 3,
  ClientPayload_ConnectReason_NETWORK_SWITCH = 4,
  ClientPayload_ConnectReason_PING_RECONNECT = 5
};
bool ClientPayload_ConnectReason_IsValid(int value);
constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MIN = ClientPayload_ConnectReason_PUSH;
constexpr ClientPayload_ConnectReason ClientPayload_ConnectReason_ConnectReason_MAX = ClientPayload_ConnectReason_PING_RECONNECT;
constexpr int ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE = ClientPayload_ConnectReason_ConnectReason_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectReason_descriptor();
template<typename T>
inline const std::string& ClientPayload_ConnectReason_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_ConnectReason>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_ConnectReason_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_ConnectReason_descriptor(), enum_t_value);
}
inline bool ClientPayload_ConnectReason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectReason* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_ConnectReason>(
    ClientPayload_ConnectReason_descriptor(), name, value);
}
enum ClientPayload_ConnectType : int {
  ClientPayload_ConnectType_CELLULAR_UNKNOWN = 0,
  ClientPayload_ConnectType_WIFI_UNKNOWN = 1,
  ClientPayload_ConnectType_CELLULAR_EDGE = 100,
  ClientPayload_ConnectType_CELLULAR_IDEN = 101,
  ClientPayload_ConnectType_CELLULAR_UMTS = 102,
  ClientPayload_ConnectType_CELLULAR_EVDO = 103,
  ClientPayload_ConnectType_CELLULAR_GPRS = 104,
  ClientPayload_ConnectType_CELLULAR_HSDPA = 105,
  ClientPayload_ConnectType_CELLULAR_HSUPA = 106,
  ClientPayload_ConnectType_CELLULAR_HSPA = 107,
  ClientPayload_ConnectType_CELLULAR_CDMA = 108,
  ClientPayload_ConnectType_CELLULAR_1XRTT = 109,
  ClientPayload_ConnectType_CELLULAR_EHRPD = 110,
  ClientPayload_ConnectType_CELLULAR_LTE = 111,
  ClientPayload_ConnectType_CELLULAR_HSPAP = 112
};
bool ClientPayload_ConnectType_IsValid(int value);
constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MIN = ClientPayload_ConnectType_CELLULAR_UNKNOWN;
constexpr ClientPayload_ConnectType ClientPayload_ConnectType_ConnectType_MAX = ClientPayload_ConnectType_CELLULAR_HSPAP;
constexpr int ClientPayload_ConnectType_ConnectType_ARRAYSIZE = ClientPayload_ConnectType_ConnectType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_ConnectType_descriptor();
template<typename T>
inline const std::string& ClientPayload_ConnectType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_ConnectType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_ConnectType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_ConnectType_descriptor(), enum_t_value);
}
inline bool ClientPayload_ConnectType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_ConnectType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_ConnectType>(
    ClientPayload_ConnectType_descriptor(), name, value);
}
enum ClientPayload_IOSAppExtension : int {
  ClientPayload_IOSAppExtension_SHARE_EXTENSION = 0,
  ClientPayload_IOSAppExtension_SERVICE_EXTENSION = 1,
  ClientPayload_IOSAppExtension_INTENTS_EXTENSION = 2
};
bool ClientPayload_IOSAppExtension_IsValid(int value);
constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MIN = ClientPayload_IOSAppExtension_SHARE_EXTENSION;
constexpr ClientPayload_IOSAppExtension ClientPayload_IOSAppExtension_IOSAppExtension_MAX = ClientPayload_IOSAppExtension_INTENTS_EXTENSION;
constexpr int ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE = ClientPayload_IOSAppExtension_IOSAppExtension_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_IOSAppExtension_descriptor();
template<typename T>
inline const std::string& ClientPayload_IOSAppExtension_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_IOSAppExtension>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_IOSAppExtension_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_IOSAppExtension_descriptor(), enum_t_value);
}
inline bool ClientPayload_IOSAppExtension_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_IOSAppExtension* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_IOSAppExtension>(
    ClientPayload_IOSAppExtension_descriptor(), name, value);
}
enum ClientPayload_Product : int {
  ClientPayload_Product_WHATSAPP = 0,
  ClientPayload_Product_MESSENGER = 1
};
bool ClientPayload_Product_IsValid(int value);
constexpr ClientPayload_Product ClientPayload_Product_Product_MIN = ClientPayload_Product_WHATSAPP;
constexpr ClientPayload_Product ClientPayload_Product_Product_MAX = ClientPayload_Product_MESSENGER;
constexpr int ClientPayload_Product_Product_ARRAYSIZE = ClientPayload_Product_Product_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientPayload_Product_descriptor();
template<typename T>
inline const std::string& ClientPayload_Product_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ClientPayload_Product>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ClientPayload_Product_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ClientPayload_Product_descriptor(), enum_t_value);
}
inline bool ClientPayload_Product_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientPayload_Product* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientPayload_Product>(
    ClientPayload_Product_descriptor(), name, value);
}
enum ContextInfo_AdReplyInfo_MediaType : int {
  ContextInfo_AdReplyInfo_MediaType_NONE = 0,
  ContextInfo_AdReplyInfo_MediaType_IMAGE = 1,
  ContextInfo_AdReplyInfo_MediaType_VIDEO = 2
};
bool ContextInfo_AdReplyInfo_MediaType_IsValid(int value);
constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MIN = ContextInfo_AdReplyInfo_MediaType_NONE;
constexpr ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo_MediaType_MediaType_MAX = ContextInfo_AdReplyInfo_MediaType_VIDEO;
constexpr int ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_AdReplyInfo_MediaType_MediaType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_AdReplyInfo_MediaType_descriptor();
template<typename T>
inline const std::string& ContextInfo_AdReplyInfo_MediaType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ContextInfo_AdReplyInfo_MediaType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ContextInfo_AdReplyInfo_MediaType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ContextInfo_AdReplyInfo_MediaType_descriptor(), enum_t_value);
}
inline bool ContextInfo_AdReplyInfo_MediaType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_AdReplyInfo_MediaType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ContextInfo_AdReplyInfo_MediaType>(
    ContextInfo_AdReplyInfo_MediaType_descriptor(), name, value);
}
enum ContextInfo_ExternalAdReplyInfo_MediaType : int {
  ContextInfo_ExternalAdReplyInfo_MediaType_NONE = 0,
  ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE = 1,
  ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO = 2
};
bool ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(int value);
constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN = ContextInfo_ExternalAdReplyInfo_MediaType_NONE;
constexpr ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX = ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO;
constexpr int ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE = ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
template<typename T>
inline const std::string& ContextInfo_ExternalAdReplyInfo_MediaType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ContextInfo_ExternalAdReplyInfo_MediaType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ContextInfo_ExternalAdReplyInfo_MediaType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), enum_t_value);
}
inline bool ContextInfo_ExternalAdReplyInfo_MediaType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ContextInfo_ExternalAdReplyInfo_MediaType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ContextInfo_ExternalAdReplyInfo_MediaType>(
    ContextInfo_ExternalAdReplyInfo_MediaType_descriptor(), name, value);
}
enum Conversation_EndOfHistoryTransferType : int {
  Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY = 0,
  Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY = 1
};
bool Conversation_EndOfHistoryTransferType_IsValid(int value);
constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN = Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY;
constexpr Conversation_EndOfHistoryTransferType Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX = Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY;
constexpr int Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE = Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Conversation_EndOfHistoryTransferType_descriptor();
template<typename T>
inline const std::string& Conversation_EndOfHistoryTransferType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Conversation_EndOfHistoryTransferType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Conversation_EndOfHistoryTransferType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Conversation_EndOfHistoryTransferType_descriptor(), enum_t_value);
}
inline bool Conversation_EndOfHistoryTransferType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Conversation_EndOfHistoryTransferType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Conversation_EndOfHistoryTransferType>(
    Conversation_EndOfHistoryTransferType_descriptor(), name, value);
}
enum DeviceProps_PlatformType : int {
  DeviceProps_PlatformType_UNKNOWN = 0,
  DeviceProps_PlatformType_CHROME = 1,
  DeviceProps_PlatformType_FIREFOX = 2,
  DeviceProps_PlatformType_IE = 3,
  DeviceProps_PlatformType_OPERA = 4,
  DeviceProps_PlatformType_SAFARI = 5,
  DeviceProps_PlatformType_EDGE = 6,
  DeviceProps_PlatformType_DESKTOP = 7,
  DeviceProps_PlatformType_IPAD = 8,
  DeviceProps_PlatformType_ANDROID_TABLET = 9,
  DeviceProps_PlatformType_OHANA = 10,
  DeviceProps_PlatformType_ALOHA = 11,
  DeviceProps_PlatformType_CATALINA = 12,
  DeviceProps_PlatformType_TCL_TV = 13
};
bool DeviceProps_PlatformType_IsValid(int value);
constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MIN = DeviceProps_PlatformType_UNKNOWN;
constexpr DeviceProps_PlatformType DeviceProps_PlatformType_PlatformType_MAX = DeviceProps_PlatformType_TCL_TV;
constexpr int DeviceProps_PlatformType_PlatformType_ARRAYSIZE = DeviceProps_PlatformType_PlatformType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceProps_PlatformType_descriptor();
template<typename T>
inline const std::string& DeviceProps_PlatformType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DeviceProps_PlatformType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DeviceProps_PlatformType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DeviceProps_PlatformType_descriptor(), enum_t_value);
}
inline bool DeviceProps_PlatformType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceProps_PlatformType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceProps_PlatformType>(
    DeviceProps_PlatformType_descriptor(), name, value);
}
enum DisappearingMode_Initiator : int {
  DisappearingMode_Initiator_CHANGED_IN_CHAT = 0,
  DisappearingMode_Initiator_INITIATED_BY_ME = 1,
  DisappearingMode_Initiator_INITIATED_BY_OTHER = 2
};
bool DisappearingMode_Initiator_IsValid(int value);
constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MIN = DisappearingMode_Initiator_CHANGED_IN_CHAT;
constexpr DisappearingMode_Initiator DisappearingMode_Initiator_Initiator_MAX = DisappearingMode_Initiator_INITIATED_BY_OTHER;
constexpr int DisappearingMode_Initiator_Initiator_ARRAYSIZE = DisappearingMode_Initiator_Initiator_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DisappearingMode_Initiator_descriptor();
template<typename T>
inline const std::string& DisappearingMode_Initiator_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DisappearingMode_Initiator>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DisappearingMode_Initiator_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DisappearingMode_Initiator_descriptor(), enum_t_value);
}
inline bool DisappearingMode_Initiator_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisappearingMode_Initiator* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DisappearingMode_Initiator>(
    DisappearingMode_Initiator_descriptor(), name, value);
}
enum GroupParticipant_Rank : int {
  GroupParticipant_Rank_REGULAR = 0,
  GroupParticipant_Rank_ADMIN = 1,
  GroupParticipant_Rank_SUPERADMIN = 2
};
bool GroupParticipant_Rank_IsValid(int value);
constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MIN = GroupParticipant_Rank_REGULAR;
constexpr GroupParticipant_Rank GroupParticipant_Rank_Rank_MAX = GroupParticipant_Rank_SUPERADMIN;
constexpr int GroupParticipant_Rank_Rank_ARRAYSIZE = GroupParticipant_Rank_Rank_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GroupParticipant_Rank_descriptor();
template<typename T>
inline const std::string& GroupParticipant_Rank_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GroupParticipant_Rank>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GroupParticipant_Rank_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GroupParticipant_Rank_descriptor(), enum_t_value);
}
inline bool GroupParticipant_Rank_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GroupParticipant_Rank* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GroupParticipant_Rank>(
    GroupParticipant_Rank_descriptor(), name, value);
}
enum HistorySync_HistorySyncType : int {
  HistorySync_HistorySyncType_INITIAL_BOOTSTRAP = 0,
  HistorySync_HistorySyncType_INITIAL_STATUS_V3 = 1,
  HistorySync_HistorySyncType_FULL = 2,
  HistorySync_HistorySyncType_RECENT = 3,
  HistorySync_HistorySyncType_PUSH_NAME = 4,
  HistorySync_HistorySyncType_UNBLOCKING_DATA = 5
};
bool HistorySync_HistorySyncType_IsValid(int value);
constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MIN = HistorySync_HistorySyncType_INITIAL_BOOTSTRAP;
constexpr HistorySync_HistorySyncType HistorySync_HistorySyncType_HistorySyncType_MAX = HistorySync_HistorySyncType_UNBLOCKING_DATA;
constexpr int HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE = HistorySync_HistorySyncType_HistorySyncType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HistorySync_HistorySyncType_descriptor();
template<typename T>
inline const std::string& HistorySync_HistorySyncType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, HistorySync_HistorySyncType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function HistorySync_HistorySyncType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    HistorySync_HistorySyncType_descriptor(), enum_t_value);
}
inline bool HistorySync_HistorySyncType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HistorySync_HistorySyncType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HistorySync_HistorySyncType>(
    HistorySync_HistorySyncType_descriptor(), name, value);
}
enum MediaRetryNotification_ResultType : int {
  MediaRetryNotification_ResultType_GENERAL_ERROR = 0,
  MediaRetryNotification_ResultType_SUCCESS = 1,
  MediaRetryNotification_ResultType_NOT_FOUND = 2,
  MediaRetryNotification_ResultType_DECRYPTION_ERROR = 3
};
bool MediaRetryNotification_ResultType_IsValid(int value);
constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MIN = MediaRetryNotification_ResultType_GENERAL_ERROR;
constexpr MediaRetryNotification_ResultType MediaRetryNotification_ResultType_ResultType_MAX = MediaRetryNotification_ResultType_DECRYPTION_ERROR;
constexpr int MediaRetryNotification_ResultType_ResultType_ARRAYSIZE = MediaRetryNotification_ResultType_ResultType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MediaRetryNotification_ResultType_descriptor();
template<typename T>
inline const std::string& MediaRetryNotification_ResultType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MediaRetryNotification_ResultType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MediaRetryNotification_ResultType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MediaRetryNotification_ResultType_descriptor(), enum_t_value);
}
inline bool MediaRetryNotification_ResultType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediaRetryNotification_ResultType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MediaRetryNotification_ResultType>(
    MediaRetryNotification_ResultType_descriptor(), name, value);
}
enum Message_ButtonsMessage_Button_Type : int {
  Message_ButtonsMessage_Button_Type_UNKNOWN = 0,
  Message_ButtonsMessage_Button_Type_RESPONSE = 1,
  Message_ButtonsMessage_Button_Type_NATIVE_FLOW = 2
};
bool Message_ButtonsMessage_Button_Type_IsValid(int value);
constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MIN = Message_ButtonsMessage_Button_Type_UNKNOWN;
constexpr Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button_Type_Type_MAX = Message_ButtonsMessage_Button_Type_NATIVE_FLOW;
constexpr int Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE = Message_ButtonsMessage_Button_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_Button_Type_descriptor();
template<typename T>
inline const std::string& Message_ButtonsMessage_Button_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ButtonsMessage_Button_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ButtonsMessage_Button_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ButtonsMessage_Button_Type_descriptor(), enum_t_value);
}
inline bool Message_ButtonsMessage_Button_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_Button_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsMessage_Button_Type>(
    Message_ButtonsMessage_Button_Type_descriptor(), name, value);
}
enum Message_ButtonsMessage_HeaderType : int {
  Message_ButtonsMessage_HeaderType_UNKNOWN = 0,
  Message_ButtonsMessage_HeaderType_EMPTY = 1,
  Message_ButtonsMessage_HeaderType_TEXT = 2,
  Message_ButtonsMessage_HeaderType_DOCUMENT = 3,
  Message_ButtonsMessage_HeaderType_IMAGE = 4,
  Message_ButtonsMessage_HeaderType_VIDEO = 5,
  Message_ButtonsMessage_HeaderType_LOCATION = 6
};
bool Message_ButtonsMessage_HeaderType_IsValid(int value);
constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MIN = Message_ButtonsMessage_HeaderType_UNKNOWN;
constexpr Message_ButtonsMessage_HeaderType Message_ButtonsMessage_HeaderType_HeaderType_MAX = Message_ButtonsMessage_HeaderType_LOCATION;
constexpr int Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE = Message_ButtonsMessage_HeaderType_HeaderType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsMessage_HeaderType_descriptor();
template<typename T>
inline const std::string& Message_ButtonsMessage_HeaderType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ButtonsMessage_HeaderType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ButtonsMessage_HeaderType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ButtonsMessage_HeaderType_descriptor(), enum_t_value);
}
inline bool Message_ButtonsMessage_HeaderType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsMessage_HeaderType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsMessage_HeaderType>(
    Message_ButtonsMessage_HeaderType_descriptor(), name, value);
}
enum Message_ButtonsResponseMessage_Type : int {
  Message_ButtonsResponseMessage_Type_UNKNOWN = 0,
  Message_ButtonsResponseMessage_Type_DISPLAY_TEXT = 1
};
bool Message_ButtonsResponseMessage_Type_IsValid(int value);
constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MIN = Message_ButtonsResponseMessage_Type_UNKNOWN;
constexpr Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage_Type_Type_MAX = Message_ButtonsResponseMessage_Type_DISPLAY_TEXT;
constexpr int Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE = Message_ButtonsResponseMessage_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ButtonsResponseMessage_Type_descriptor();
template<typename T>
inline const std::string& Message_ButtonsResponseMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ButtonsResponseMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ButtonsResponseMessage_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ButtonsResponseMessage_Type_descriptor(), enum_t_value);
}
inline bool Message_ButtonsResponseMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ButtonsResponseMessage_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ButtonsResponseMessage_Type>(
    Message_ButtonsResponseMessage_Type_descriptor(), name, value);
}
enum Message_ExtendedTextMessage_FontType : int {
  Message_ExtendedTextMessage_FontType_SANS_SERIF = 0,
  Message_ExtendedTextMessage_FontType_SERIF = 1,
  Message_ExtendedTextMessage_FontType_NORICAN_REGULAR = 2,
  Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE = 3,
  Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR = 4,
  Message_ExtendedTextMessage_FontType_OSWALD_HEAVY = 5
};
bool Message_ExtendedTextMessage_FontType_IsValid(int value);
constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MIN = Message_ExtendedTextMessage_FontType_SANS_SERIF;
constexpr Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage_FontType_FontType_MAX = Message_ExtendedTextMessage_FontType_OSWALD_HEAVY;
constexpr int Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE = Message_ExtendedTextMessage_FontType_FontType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_FontType_descriptor();
template<typename T>
inline const std::string& Message_ExtendedTextMessage_FontType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ExtendedTextMessage_FontType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ExtendedTextMessage_FontType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ExtendedTextMessage_FontType_descriptor(), enum_t_value);
}
inline bool Message_ExtendedTextMessage_FontType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_FontType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_FontType>(
    Message_ExtendedTextMessage_FontType_descriptor(), name, value);
}
enum Message_ExtendedTextMessage_InviteLinkGroupType : int {
  Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT = 0,
  Message_ExtendedTextMessage_InviteLinkGroupType_PARENT = 1,
  Message_ExtendedTextMessage_InviteLinkGroupType_SUB = 2,
  Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB = 3
};
bool Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(int value);
constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT;
constexpr Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX = Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB;
constexpr int Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE = Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
template<typename T>
inline const std::string& Message_ExtendedTextMessage_InviteLinkGroupType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ExtendedTextMessage_InviteLinkGroupType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ExtendedTextMessage_InviteLinkGroupType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), enum_t_value);
}
inline bool Message_ExtendedTextMessage_InviteLinkGroupType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_InviteLinkGroupType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_InviteLinkGroupType>(
    Message_ExtendedTextMessage_InviteLinkGroupType_descriptor(), name, value);
}
enum Message_ExtendedTextMessage_PreviewType : int {
  Message_ExtendedTextMessage_PreviewType_NONE = 0,
  Message_ExtendedTextMessage_PreviewType_VIDEO = 1
};
bool Message_ExtendedTextMessage_PreviewType_IsValid(int value);
constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MIN = Message_ExtendedTextMessage_PreviewType_NONE;
constexpr Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage_PreviewType_PreviewType_MAX = Message_ExtendedTextMessage_PreviewType_VIDEO;
constexpr int Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE = Message_ExtendedTextMessage_PreviewType_PreviewType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ExtendedTextMessage_PreviewType_descriptor();
template<typename T>
inline const std::string& Message_ExtendedTextMessage_PreviewType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ExtendedTextMessage_PreviewType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ExtendedTextMessage_PreviewType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ExtendedTextMessage_PreviewType_descriptor(), enum_t_value);
}
inline bool Message_ExtendedTextMessage_PreviewType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ExtendedTextMessage_PreviewType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ExtendedTextMessage_PreviewType>(
    Message_ExtendedTextMessage_PreviewType_descriptor(), name, value);
}
enum Message_GroupInviteMessage_GroupType : int {
  Message_GroupInviteMessage_GroupType_DEFAULT = 0,
  Message_GroupInviteMessage_GroupType_PARENT = 1
};
bool Message_GroupInviteMessage_GroupType_IsValid(int value);
constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MIN = Message_GroupInviteMessage_GroupType_DEFAULT;
constexpr Message_GroupInviteMessage_GroupType Message_GroupInviteMessage_GroupType_GroupType_MAX = Message_GroupInviteMessage_GroupType_PARENT;
constexpr int Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE = Message_GroupInviteMessage_GroupType_GroupType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_GroupInviteMessage_GroupType_descriptor();
template<typename T>
inline const std::string& Message_GroupInviteMessage_GroupType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_GroupInviteMessage_GroupType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_GroupInviteMessage_GroupType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_GroupInviteMessage_GroupType_descriptor(), enum_t_value);
}
inline bool Message_GroupInviteMessage_GroupType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_GroupInviteMessage_GroupType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_GroupInviteMessage_GroupType>(
    Message_GroupInviteMessage_GroupType_descriptor(), name, value);
}
enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType : int {
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN = 1,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI = 2
};
bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(int value);
constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN;
constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI;
constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
template<typename T>
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), enum_t_value);
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>(
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor(), name, value);
}
enum Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType : int {
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY = 1,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY = 2,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY = 3,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY = 4,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY = 5,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY = 6,
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY = 7
};
bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(int value);
constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY;
constexpr Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY;
constexpr int Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE = Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
template<typename T>
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), enum_t_value);
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>(
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor(), name, value);
}
enum Message_HistorySyncNotification_HistorySyncType : int {
  Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP = 0,
  Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3 = 1,
  Message_HistorySyncNotification_HistorySyncType_FULL = 2,
  Message_HistorySyncNotification_HistorySyncType_RECENT = 3,
  Message_HistorySyncNotification_HistorySyncType_PUSH_NAME = 4
};
bool Message_HistorySyncNotification_HistorySyncType_IsValid(int value);
constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN = Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP;
constexpr Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX = Message_HistorySyncNotification_HistorySyncType_PUSH_NAME;
constexpr int Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE = Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_HistorySyncNotification_HistorySyncType_descriptor();
template<typename T>
inline const std::string& Message_HistorySyncNotification_HistorySyncType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_HistorySyncNotification_HistorySyncType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_HistorySyncNotification_HistorySyncType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_HistorySyncNotification_HistorySyncType_descriptor(), enum_t_value);
}
inline bool Message_HistorySyncNotification_HistorySyncType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_HistorySyncNotification_HistorySyncType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_HistorySyncNotification_HistorySyncType>(
    Message_HistorySyncNotification_HistorySyncType_descriptor(), name, value);
}
enum Message_InteractiveMessage_ShopMessage_Surface : int {
  Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE = 0,
  Message_InteractiveMessage_ShopMessage_Surface_FB = 1,
  Message_InteractiveMessage_ShopMessage_Surface_IG = 2,
  Message_InteractiveMessage_ShopMessage_Surface_WA = 3
};
bool Message_InteractiveMessage_ShopMessage_Surface_IsValid(int value);
constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN = Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE;
constexpr Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX = Message_InteractiveMessage_ShopMessage_Surface_WA;
constexpr int Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE = Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InteractiveMessage_ShopMessage_Surface_descriptor();
template<typename T>
inline const std::string& Message_InteractiveMessage_ShopMessage_Surface_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_InteractiveMessage_ShopMessage_Surface>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_InteractiveMessage_ShopMessage_Surface_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_InteractiveMessage_ShopMessage_Surface_descriptor(), enum_t_value);
}
inline bool Message_InteractiveMessage_ShopMessage_Surface_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InteractiveMessage_ShopMessage_Surface* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_InteractiveMessage_ShopMessage_Surface>(
    Message_InteractiveMessage_ShopMessage_Surface_descriptor(), name, value);
}
enum Message_InvoiceMessage_AttachmentType : int {
  Message_InvoiceMessage_AttachmentType_IMAGE = 0,
  Message_InvoiceMessage_AttachmentType_PDF = 1
};
bool Message_InvoiceMessage_AttachmentType_IsValid(int value);
constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MIN = Message_InvoiceMessage_AttachmentType_IMAGE;
constexpr Message_InvoiceMessage_AttachmentType Message_InvoiceMessage_AttachmentType_AttachmentType_MAX = Message_InvoiceMessage_AttachmentType_PDF;
constexpr int Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE = Message_InvoiceMessage_AttachmentType_AttachmentType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_InvoiceMessage_AttachmentType_descriptor();
template<typename T>
inline const std::string& Message_InvoiceMessage_AttachmentType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_InvoiceMessage_AttachmentType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_InvoiceMessage_AttachmentType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_InvoiceMessage_AttachmentType_descriptor(), enum_t_value);
}
inline bool Message_InvoiceMessage_AttachmentType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_InvoiceMessage_AttachmentType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_InvoiceMessage_AttachmentType>(
    Message_InvoiceMessage_AttachmentType_descriptor(), name, value);
}
enum Message_ListMessage_ListType : int {
  Message_ListMessage_ListType_UNKNOWN = 0,
  Message_ListMessage_ListType_SINGLE_SELECT = 1,
  Message_ListMessage_ListType_PRODUCT_LIST = 2
};
bool Message_ListMessage_ListType_IsValid(int value);
constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MIN = Message_ListMessage_ListType_UNKNOWN;
constexpr Message_ListMessage_ListType Message_ListMessage_ListType_ListType_MAX = Message_ListMessage_ListType_PRODUCT_LIST;
constexpr int Message_ListMessage_ListType_ListType_ARRAYSIZE = Message_ListMessage_ListType_ListType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListMessage_ListType_descriptor();
template<typename T>
inline const std::string& Message_ListMessage_ListType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ListMessage_ListType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ListMessage_ListType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ListMessage_ListType_descriptor(), enum_t_value);
}
inline bool Message_ListMessage_ListType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListMessage_ListType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ListMessage_ListType>(
    Message_ListMessage_ListType_descriptor(), name, value);
}
enum Message_ListResponseMessage_ListType : int {
  Message_ListResponseMessage_ListType_UNKNOWN = 0,
  Message_ListResponseMessage_ListType_SINGLE_SELECT = 1
};
bool Message_ListResponseMessage_ListType_IsValid(int value);
constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MIN = Message_ListResponseMessage_ListType_UNKNOWN;
constexpr Message_ListResponseMessage_ListType Message_ListResponseMessage_ListType_ListType_MAX = Message_ListResponseMessage_ListType_SINGLE_SELECT;
constexpr int Message_ListResponseMessage_ListType_ListType_ARRAYSIZE = Message_ListResponseMessage_ListType_ListType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ListResponseMessage_ListType_descriptor();
template<typename T>
inline const std::string& Message_ListResponseMessage_ListType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ListResponseMessage_ListType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ListResponseMessage_ListType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ListResponseMessage_ListType_descriptor(), enum_t_value);
}
inline bool Message_ListResponseMessage_ListType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ListResponseMessage_ListType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ListResponseMessage_ListType>(
    Message_ListResponseMessage_ListType_descriptor(), name, value);
}
enum Message_OrderMessage_OrderStatus : int {
  Message_OrderMessage_OrderStatus_INQUIRY = 1
};
bool Message_OrderMessage_OrderStatus_IsValid(int value);
constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MIN = Message_OrderMessage_OrderStatus_INQUIRY;
constexpr Message_OrderMessage_OrderStatus Message_OrderMessage_OrderStatus_OrderStatus_MAX = Message_OrderMessage_OrderStatus_INQUIRY;
constexpr int Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE = Message_OrderMessage_OrderStatus_OrderStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderStatus_descriptor();
template<typename T>
inline const std::string& Message_OrderMessage_OrderStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_OrderMessage_OrderStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_OrderMessage_OrderStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_OrderMessage_OrderStatus_descriptor(), enum_t_value);
}
inline bool Message_OrderMessage_OrderStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_OrderMessage_OrderStatus>(
    Message_OrderMessage_OrderStatus_descriptor(), name, value);
}
enum Message_OrderMessage_OrderSurface : int {
  Message_OrderMessage_OrderSurface_CATALOG = 1
};
bool Message_OrderMessage_OrderSurface_IsValid(int value);
constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MIN = Message_OrderMessage_OrderSurface_CATALOG;
constexpr Message_OrderMessage_OrderSurface Message_OrderMessage_OrderSurface_OrderSurface_MAX = Message_OrderMessage_OrderSurface_CATALOG;
constexpr int Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE = Message_OrderMessage_OrderSurface_OrderSurface_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_OrderMessage_OrderSurface_descriptor();
template<typename T>
inline const std::string& Message_OrderMessage_OrderSurface_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_OrderMessage_OrderSurface>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_OrderMessage_OrderSurface_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_OrderMessage_OrderSurface_descriptor(), enum_t_value);
}
inline bool Message_OrderMessage_OrderSurface_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_OrderMessage_OrderSurface* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_OrderMessage_OrderSurface>(
    Message_OrderMessage_OrderSurface_descriptor(), name, value);
}
enum Message_PaymentInviteMessage_ServiceType : int {
  Message_PaymentInviteMessage_ServiceType_UNKNOWN = 0,
  Message_PaymentInviteMessage_ServiceType_FBPAY = 1,
  Message_PaymentInviteMessage_ServiceType_NOVI = 2,
  Message_PaymentInviteMessage_ServiceType_UPI = 3
};
bool Message_PaymentInviteMessage_ServiceType_IsValid(int value);
constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MIN = Message_PaymentInviteMessage_ServiceType_UNKNOWN;
constexpr Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage_ServiceType_ServiceType_MAX = Message_PaymentInviteMessage_ServiceType_UPI;
constexpr int Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE = Message_PaymentInviteMessage_ServiceType_ServiceType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_PaymentInviteMessage_ServiceType_descriptor();
template<typename T>
inline const std::string& Message_PaymentInviteMessage_ServiceType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_PaymentInviteMessage_ServiceType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_PaymentInviteMessage_ServiceType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_PaymentInviteMessage_ServiceType_descriptor(), enum_t_value);
}
inline bool Message_PaymentInviteMessage_ServiceType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_PaymentInviteMessage_ServiceType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_PaymentInviteMessage_ServiceType>(
    Message_PaymentInviteMessage_ServiceType_descriptor(), name, value);
}
enum Message_ProtocolMessage_Type : int {
  Message_ProtocolMessage_Type_REVOKE = 0,
  Message_ProtocolMessage_Type_EPHEMERAL_SETTING = 3,
  Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE = 4,
  Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION = 5,
  Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE = 6,
  Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST = 7,
  Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST = 8,
  Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC = 9,
  Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION = 10,
  Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER = 11,
  Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE = 12,
  Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE = 13
};
bool Message_ProtocolMessage_Type_IsValid(int value);
constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MIN = Message_ProtocolMessage_Type_REVOKE;
constexpr Message_ProtocolMessage_Type Message_ProtocolMessage_Type_Type_MAX = Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE;
constexpr int Message_ProtocolMessage_Type_Type_ARRAYSIZE = Message_ProtocolMessage_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_ProtocolMessage_Type_descriptor();
template<typename T>
inline const std::string& Message_ProtocolMessage_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_ProtocolMessage_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_ProtocolMessage_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_ProtocolMessage_Type_descriptor(), enum_t_value);
}
inline bool Message_ProtocolMessage_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_ProtocolMessage_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_ProtocolMessage_Type>(
    Message_ProtocolMessage_Type_descriptor(), name, value);
}
enum Message_VideoMessage_Attribution : int {
  Message_VideoMessage_Attribution_NONE = 0,
  Message_VideoMessage_Attribution_GIPHY = 1,
  Message_VideoMessage_Attribution_TENOR = 2
};
bool Message_VideoMessage_Attribution_IsValid(int value);
constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MIN = Message_VideoMessage_Attribution_NONE;
constexpr Message_VideoMessage_Attribution Message_VideoMessage_Attribution_Attribution_MAX = Message_VideoMessage_Attribution_TENOR;
constexpr int Message_VideoMessage_Attribution_Attribution_ARRAYSIZE = Message_VideoMessage_Attribution_Attribution_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_VideoMessage_Attribution_descriptor();
template<typename T>
inline const std::string& Message_VideoMessage_Attribution_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_VideoMessage_Attribution>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_VideoMessage_Attribution_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_VideoMessage_Attribution_descriptor(), enum_t_value);
}
inline bool Message_VideoMessage_Attribution_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_VideoMessage_Attribution* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_VideoMessage_Attribution>(
    Message_VideoMessage_Attribution_descriptor(), name, value);
}
enum Message_RmrSource : int {
  Message_RmrSource_FAVORITE_STICKER = 0,
  Message_RmrSource_RECENT_STICKER = 1
};
bool Message_RmrSource_IsValid(int value);
constexpr Message_RmrSource Message_RmrSource_RmrSource_MIN = Message_RmrSource_FAVORITE_STICKER;
constexpr Message_RmrSource Message_RmrSource_RmrSource_MAX = Message_RmrSource_RECENT_STICKER;
constexpr int Message_RmrSource_RmrSource_ARRAYSIZE = Message_RmrSource_RmrSource_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_RmrSource_descriptor();
template<typename T>
inline const std::string& Message_RmrSource_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_RmrSource>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_RmrSource_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_RmrSource_descriptor(), enum_t_value);
}
inline bool Message_RmrSource_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Message_RmrSource* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_RmrSource>(
    Message_RmrSource_descriptor(), name, value);
}
enum PastParticipant_LeaveReason : int {
  PastParticipant_LeaveReason_LEFT = 0,
  PastParticipant_LeaveReason_REMOVED = 1
};
bool PastParticipant_LeaveReason_IsValid(int value);
constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MIN = PastParticipant_LeaveReason_LEFT;
constexpr PastParticipant_LeaveReason PastParticipant_LeaveReason_LeaveReason_MAX = PastParticipant_LeaveReason_REMOVED;
constexpr int PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE = PastParticipant_LeaveReason_LeaveReason_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PastParticipant_LeaveReason_descriptor();
template<typename T>
inline const std::string& PastParticipant_LeaveReason_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PastParticipant_LeaveReason>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PastParticipant_LeaveReason_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PastParticipant_LeaveReason_descriptor(), enum_t_value);
}
inline bool PastParticipant_LeaveReason_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PastParticipant_LeaveReason* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PastParticipant_LeaveReason>(
    PastParticipant_LeaveReason_descriptor(), name, value);
}
enum PaymentBackground_Type : int {
  PaymentBackground_Type_UNKNOWN = 0,
  PaymentBackground_Type_DEFAULT = 1
};
bool PaymentBackground_Type_IsValid(int value);
constexpr PaymentBackground_Type PaymentBackground_Type_Type_MIN = PaymentBackground_Type_UNKNOWN;
constexpr PaymentBackground_Type PaymentBackground_Type_Type_MAX = PaymentBackground_Type_DEFAULT;
constexpr int PaymentBackground_Type_Type_ARRAYSIZE = PaymentBackground_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentBackground_Type_descriptor();
template<typename T>
inline const std::string& PaymentBackground_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PaymentBackground_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PaymentBackground_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PaymentBackground_Type_descriptor(), enum_t_value);
}
inline bool PaymentBackground_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentBackground_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentBackground_Type>(
    PaymentBackground_Type_descriptor(), name, value);
}
enum PaymentInfo_Currency : int {
  PaymentInfo_Currency_UNKNOWN_CURRENCY = 0,
  PaymentInfo_Currency_INR = 1
};
bool PaymentInfo_Currency_IsValid(int value);
constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MIN = PaymentInfo_Currency_UNKNOWN_CURRENCY;
constexpr PaymentInfo_Currency PaymentInfo_Currency_Currency_MAX = PaymentInfo_Currency_INR;
constexpr int PaymentInfo_Currency_Currency_ARRAYSIZE = PaymentInfo_Currency_Currency_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Currency_descriptor();
template<typename T>
inline const std::string& PaymentInfo_Currency_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PaymentInfo_Currency>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PaymentInfo_Currency_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PaymentInfo_Currency_descriptor(), enum_t_value);
}
inline bool PaymentInfo_Currency_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Currency* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_Currency>(
    PaymentInfo_Currency_descriptor(), name, value);
}
enum PaymentInfo_Status : int {
  PaymentInfo_Status_UNKNOWN_STATUS = 0,
  PaymentInfo_Status_PROCESSING = 1,
  PaymentInfo_Status_SENT = 2,
  PaymentInfo_Status_NEED_TO_ACCEPT = 3,
  PaymentInfo_Status_COMPLETE = 4,
  PaymentInfo_Status_COULD_NOT_COMPLETE = 5,
  PaymentInfo_Status_REFUNDED = 6,
  PaymentInfo_Status_EXPIRED = 7,
  PaymentInfo_Status_REJECTED = 8,
  PaymentInfo_Status_CANCELLED = 9,
  PaymentInfo_Status_WAITING_FOR_PAYER = 10,
  PaymentInfo_Status_WAITING = 11
};
bool PaymentInfo_Status_IsValid(int value);
constexpr PaymentInfo_Status PaymentInfo_Status_Status_MIN = PaymentInfo_Status_UNKNOWN_STATUS;
constexpr PaymentInfo_Status PaymentInfo_Status_Status_MAX = PaymentInfo_Status_WAITING;
constexpr int PaymentInfo_Status_Status_ARRAYSIZE = PaymentInfo_Status_Status_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_Status_descriptor();
template<typename T>
inline const std::string& PaymentInfo_Status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PaymentInfo_Status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PaymentInfo_Status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PaymentInfo_Status_descriptor(), enum_t_value);
}
inline bool PaymentInfo_Status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_Status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_Status>(
    PaymentInfo_Status_descriptor(), name, value);
}
enum PaymentInfo_TxnStatus : int {
  PaymentInfo_TxnStatus_UNKNOWN = 0,
  PaymentInfo_TxnStatus_PENDING_SETUP = 1,
  PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP = 2,
  PaymentInfo_TxnStatus_INIT = 3,
  PaymentInfo_TxnStatus_SUCCESS = 4,
  PaymentInfo_TxnStatus_COMPLETED = 5,
  PaymentInfo_TxnStatus_FAILED = 6,
  PaymentInfo_TxnStatus_FAILED_RISK = 7,
  PaymentInfo_TxnStatus_FAILED_PROCESSING = 8,
  PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING = 9,
  PaymentInfo_TxnStatus_FAILED_DA = 10,
  PaymentInfo_TxnStatus_FAILED_DA_FINAL = 11,
  PaymentInfo_TxnStatus_REFUNDED_TXN = 12,
  PaymentInfo_TxnStatus_REFUND_FAILED = 13,
  PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING = 14,
  PaymentInfo_TxnStatus_REFUND_FAILED_DA = 15,
  PaymentInfo_TxnStatus_EXPIRED_TXN = 16,
  PaymentInfo_TxnStatus_AUTH_CANCELED = 17,
  PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING = 18,
  PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED = 19,
  PaymentInfo_TxnStatus_COLLECT_INIT = 20,
  PaymentInfo_TxnStatus_COLLECT_SUCCESS = 21,
  PaymentInfo_TxnStatus_COLLECT_FAILED = 22,
  PaymentInfo_TxnStatus_COLLECT_FAILED_RISK = 23,
  PaymentInfo_TxnStatus_COLLECT_REJECTED = 24,
  PaymentInfo_TxnStatus_COLLECT_EXPIRED = 25,
  PaymentInfo_TxnStatus_COLLECT_CANCELED = 26,
  PaymentInfo_TxnStatus_COLLECT_CANCELLING = 27,
  PaymentInfo_TxnStatus_IN_REVIEW = 28,
  PaymentInfo_TxnStatus_REVERSAL_SUCCESS = 29,
  PaymentInfo_TxnStatus_REVERSAL_PENDING = 30,
  PaymentInfo_TxnStatus_REFUND_PENDING = 31
};
bool PaymentInfo_TxnStatus_IsValid(int value);
constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MIN = PaymentInfo_TxnStatus_UNKNOWN;
constexpr PaymentInfo_TxnStatus PaymentInfo_TxnStatus_TxnStatus_MAX = PaymentInfo_TxnStatus_REFUND_PENDING;
constexpr int PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE = PaymentInfo_TxnStatus_TxnStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PaymentInfo_TxnStatus_descriptor();
template<typename T>
inline const std::string& PaymentInfo_TxnStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PaymentInfo_TxnStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PaymentInfo_TxnStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PaymentInfo_TxnStatus_descriptor(), enum_t_value);
}
inline bool PaymentInfo_TxnStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PaymentInfo_TxnStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PaymentInfo_TxnStatus>(
    PaymentInfo_TxnStatus_descriptor(), name, value);
}
enum SyncdMutation_SyncdOperation : int {
  SyncdMutation_SyncdOperation_SET = 0,
  SyncdMutation_SyncdOperation_REMOVE = 1
};
bool SyncdMutation_SyncdOperation_IsValid(int value);
constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MIN = SyncdMutation_SyncdOperation_SET;
constexpr SyncdMutation_SyncdOperation SyncdMutation_SyncdOperation_SyncdOperation_MAX = SyncdMutation_SyncdOperation_REMOVE;
constexpr int SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE = SyncdMutation_SyncdOperation_SyncdOperation_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SyncdMutation_SyncdOperation_descriptor();
template<typename T>
inline const std::string& SyncdMutation_SyncdOperation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SyncdMutation_SyncdOperation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SyncdMutation_SyncdOperation_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SyncdMutation_SyncdOperation_descriptor(), enum_t_value);
}
inline bool SyncdMutation_SyncdOperation_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncdMutation_SyncdOperation* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SyncdMutation_SyncdOperation>(
    SyncdMutation_SyncdOperation_descriptor(), name, value);
}
enum WebFeatures_Flag : int {
  WebFeatures_Flag_NOT_STARTED = 0,
  WebFeatures_Flag_FORCE_UPGRADE = 1,
  WebFeatures_Flag_DEVELOPMENT = 2,
  WebFeatures_Flag_PRODUCTION = 3
};
bool WebFeatures_Flag_IsValid(int value);
constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MIN = WebFeatures_Flag_NOT_STARTED;
constexpr WebFeatures_Flag WebFeatures_Flag_Flag_MAX = WebFeatures_Flag_PRODUCTION;
constexpr int WebFeatures_Flag_Flag_ARRAYSIZE = WebFeatures_Flag_Flag_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebFeatures_Flag_descriptor();
template<typename T>
inline const std::string& WebFeatures_Flag_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WebFeatures_Flag>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WebFeatures_Flag_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WebFeatures_Flag_descriptor(), enum_t_value);
}
inline bool WebFeatures_Flag_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebFeatures_Flag* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebFeatures_Flag>(
    WebFeatures_Flag_descriptor(), name, value);
}
enum WebMessageInfo_BizPrivacyStatus : int {
  WebMessageInfo_BizPrivacyStatus_E2EE = 0,
  WebMessageInfo_BizPrivacyStatus_FB = 2,
  WebMessageInfo_BizPrivacyStatus_BSP = 1,
  WebMessageInfo_BizPrivacyStatus_BSP_AND_FB = 3
};
bool WebMessageInfo_BizPrivacyStatus_IsValid(int value);
constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN = WebMessageInfo_BizPrivacyStatus_E2EE;
constexpr WebMessageInfo_BizPrivacyStatus WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX = WebMessageInfo_BizPrivacyStatus_BSP_AND_FB;
constexpr int WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE = WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_BizPrivacyStatus_descriptor();
template<typename T>
inline const std::string& WebMessageInfo_BizPrivacyStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WebMessageInfo_BizPrivacyStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WebMessageInfo_BizPrivacyStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WebMessageInfo_BizPrivacyStatus_descriptor(), enum_t_value);
}
inline bool WebMessageInfo_BizPrivacyStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_BizPrivacyStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_BizPrivacyStatus>(
    WebMessageInfo_BizPrivacyStatus_descriptor(), name, value);
}
enum WebMessageInfo_Status : int {
  WebMessageInfo_Status_ERROR = 0,
  WebMessageInfo_Status_PENDING = 1,
  WebMessageInfo_Status_SERVER_ACK = 2,
  WebMessageInfo_Status_DELIVERY_ACK = 3,
  WebMessageInfo_Status_READ = 4,
  WebMessageInfo_Status_PLAYED = 5
};
bool WebMessageInfo_Status_IsValid(int value);
constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MIN = WebMessageInfo_Status_ERROR;
constexpr WebMessageInfo_Status WebMessageInfo_Status_Status_MAX = WebMessageInfo_Status_PLAYED;
constexpr int WebMessageInfo_Status_Status_ARRAYSIZE = WebMessageInfo_Status_Status_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_Status_descriptor();
template<typename T>
inline const std::string& WebMessageInfo_Status_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WebMessageInfo_Status>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WebMessageInfo_Status_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WebMessageInfo_Status_descriptor(), enum_t_value);
}
inline bool WebMessageInfo_Status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_Status* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_Status>(
    WebMessageInfo_Status_descriptor(), name, value);
}
enum WebMessageInfo_StubType : int {
  WebMessageInfo_StubType_UNKNOWN = 0,
  WebMessageInfo_StubType_REVOKE = 1,
  WebMessageInfo_StubType_CIPHERTEXT = 2,
  WebMessageInfo_StubType_FUTUREPROOF = 3,
  WebMessageInfo_StubType_NON_VERIFIED_TRANSITION = 4,
  WebMessageInfo_StubType_UNVERIFIED_TRANSITION = 5,
  WebMessageInfo_StubType_VERIFIED_TRANSITION = 6,
  WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN = 7,
  WebMessageInfo_StubType_VERIFIED_HIGH = 8,
  WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN = 9,
  WebMessageInfo_StubType_VERIFIED_INITIAL_LOW = 10,
  WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH = 11,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE = 12,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH = 13,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW = 14,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN = 15,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW = 16,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN = 17,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW = 18,
  WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN = 19,
  WebMessageInfo_StubType_GROUP_CREATE = 20,
  WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT = 21,
  WebMessageInfo_StubType_GROUP_CHANGE_ICON = 22,
  WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK = 23,
  WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION = 24,
  WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT = 25,
  WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE = 26,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD = 27,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE = 28,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE = 29,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE = 30,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE = 31,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE = 32,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER = 33,
  WebMessageInfo_StubType_BROADCAST_CREATE = 34,
  WebMessageInfo_StubType_BROADCAST_ADD = 35,
  WebMessageInfo_StubType_BROADCAST_REMOVE = 36,
  WebMessageInfo_StubType_GENERIC_NOTIFICATION = 37,
  WebMessageInfo_StubType_E2E_IDENTITY_CHANGED = 38,
  WebMessageInfo_StubType_E2E_ENCRYPTED = 39,
  WebMessageInfo_StubType_CALL_MISSED_VOICE = 40,
  WebMessageInfo_StubType_CALL_MISSED_VIDEO = 41,
  WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER = 42,
  WebMessageInfo_StubType_GROUP_DELETE = 43,
  WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE = 44,
  WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE = 45,
  WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO = 46,
  WebMessageInfo_StubType_PAYMENT_CIPHERTEXT = 47,
  WebMessageInfo_StubType_PAYMENT_FUTUREPROOF = 48,
  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED = 49,
  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED = 50,
  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED = 51,
  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP = 52,
  WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP = 53,
  WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER = 54,
  WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER = 55,
  WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION = 56,
  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED = 57,
  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED = 58,
  WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED = 59,
  WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM = 60,
  WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP = 61,
  WebMessageInfo_StubType_BIZ_INTRO_TOP = 62,
  WebMessageInfo_StubType_BIZ_INTRO_BOTTOM = 63,
  WebMessageInfo_StubType_BIZ_NAME_CHANGE = 64,
  WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP = 65,
  WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP = 66,
  WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM = 67,
  WebMessageInfo_StubType_OVERSIZED = 68,
  WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED = 69,
  WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT = 70,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN = 71,
  WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING = 72,
  WebMessageInfo_StubType_E2E_DEVICE_CHANGED = 73,
  WebMessageInfo_StubType_VIEWED_ONCE = 74,
  WebMessageInfo_StubType_E2E_ENCRYPTED_NOW = 75,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE = 76,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB = 77,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE = 78,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED = 79,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 80,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED = 81,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 82,
  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE = 83,
  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED = 84,
  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 85,
  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED = 86,
  WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 87,
  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED = 88,
  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED = 89,
  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED = 90,
  WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED = 91,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE = 92,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE = 93,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED = 94,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED = 95,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED = 96,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED = 97,
  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE = 98,
  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED = 99,
  WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED = 100,
  WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB = 101,
  WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER = 102,
  WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB = 103,
  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED = 104,
  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 105,
  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED = 106,
  WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED = 107,
  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED = 108,
  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 109,
  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED = 110,
  WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED = 111,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 112,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED = 113,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 114,
  WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED = 115,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED = 116,
  WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED = 117,
  WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE = 118,
  WebMessageInfo_StubType_GROUP_CREATING = 119,
  WebMessageInfo_StubType_GROUP_CREATE_FAILED = 120,
  WebMessageInfo_StubType_GROUP_BOUNCED = 121,
  WebMessageInfo_StubType_BLOCK_CONTACT = 122,
  WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED = 123,
  WebMessageInfo_StubType_SYNC_FAILED = 124,
  WebMessageInfo_StubType_SYNCING = 125,
  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB = 126,
  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP = 127,
  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB = 128,
  WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP = 129,
  WebMessageInfo_StubType_DISAPPEARING_MODE = 130,
  WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED = 131,
  WebMessageInfo_StubType_ADMIN_REVOKE = 132,
  WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED = 133,
  WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP = 134,
  WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP = 135,
  WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP = 136,
  WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP = 137,
  WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP = 138,
  WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP = 139,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT = 140,
  WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN = 141,
  WebMessageInfo_StubType_COMMUNITY_CREATE = 142,
  WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT = 143,
  WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST = 144,
  WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE = 145,
  WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP = 146,
  WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE = 147,
  WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE = 148,
  WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED = 149
};
bool WebMessageInfo_StubType_IsValid(int value);
constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MIN = WebMessageInfo_StubType_UNKNOWN;
constexpr WebMessageInfo_StubType WebMessageInfo_StubType_StubType_MAX = WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED;
constexpr int WebMessageInfo_StubType_StubType_ARRAYSIZE = WebMessageInfo_StubType_StubType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WebMessageInfo_StubType_descriptor();
template<typename T>
inline const std::string& WebMessageInfo_StubType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, WebMessageInfo_StubType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function WebMessageInfo_StubType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    WebMessageInfo_StubType_descriptor(), enum_t_value);
}
inline bool WebMessageInfo_StubType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WebMessageInfo_StubType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WebMessageInfo_StubType>(
    WebMessageInfo_StubType_descriptor(), name, value);
}
enum KeepType : int {
  UNKNOWN = 0,
  KEEP_FOR_ALL = 1,
  UNDO_KEEP_FOR_ALL = 2
};
bool KeepType_IsValid(int value);
constexpr KeepType KeepType_MIN = UNKNOWN;
constexpr KeepType KeepType_MAX = UNDO_KEEP_FOR_ALL;
constexpr int KeepType_ARRAYSIZE = KeepType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeepType_descriptor();
template<typename T>
inline const std::string& KeepType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, KeepType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function KeepType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    KeepType_descriptor(), enum_t_value);
}
inline bool KeepType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeepType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeepType>(
    KeepType_descriptor(), name, value);
}
enum MediaVisibility : int {
  DEFAULT = 0,
  OFF = 1,
  ON = 2
};
bool MediaVisibility_IsValid(int value);
constexpr MediaVisibility MediaVisibility_MIN = DEFAULT;
constexpr MediaVisibility MediaVisibility_MAX = ON;
constexpr int MediaVisibility_ARRAYSIZE = MediaVisibility_MAX + 1;

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

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ADVDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADVDeviceIdentity>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADVDeviceIdentity& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADVDeviceIdentity& from) {
    ADVDeviceIdentity::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kTimestampFieldNumber = 2,
    kRawIdFieldNumber = 1,
    kKeyIndexFieldNumber = 3,
  };
  // 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:

  // optional uint32 rawId = 1;
  bool has_rawid() const;
  private:
  bool _internal_has_rawid() const;
  public:
  void clear_rawid();
  uint32_t rawid() const;
  void set_rawid(uint32_t value);
  private:
  uint32_t _internal_rawid() const;
  void _internal_set_rawid(uint32_t value);
  public:

  // optional uint32 keyIndex = 3;
  bool has_keyindex() const;
  private:
  bool _internal_has_keyindex() const;
  public:
  void clear_keyindex();
  uint32_t keyindex() const;
  void set_keyindex(uint32_t value);
  private:
  uint32_t _internal_keyindex() const;
  void _internal_set_keyindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ADVDeviceIdentity)
 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_;
    uint32_t rawid_;
    uint32_t keyindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ADVKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADVKeyIndexList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADVKeyIndexList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADVKeyIndexList& from) {
    ADVKeyIndexList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kValidIndexesFieldNumber = 4,
    kTimestampFieldNumber = 2,
    kRawIdFieldNumber = 1,
    kCurrentIndexFieldNumber = 3,
  };
  // repeated uint32 validIndexes = 4 [packed = true];
  int validindexes_size() const;
  private:
  int _internal_validindexes_size() const;
  public:
  void clear_validindexes();
  private:
  uint32_t _internal_validindexes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_validindexes() const;
  void _internal_add_validindexes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_validindexes();
  public:
  uint32_t validindexes(int index) const;
  void set_validindexes(int index, uint32_t value);
  void add_validindexes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      validindexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_validindexes();

  // 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:

  // optional uint32 rawId = 1;
  bool has_rawid() const;
  private:
  bool _internal_has_rawid() const;
  public:
  void clear_rawid();
  uint32_t rawid() const;
  void set_rawid(uint32_t value);
  private:
  uint32_t _internal_rawid() const;
  void _internal_set_rawid(uint32_t value);
  public:

  // optional uint32 currentIndex = 3;
  bool has_currentindex() const;
  private:
  bool _internal_has_currentindex() const;
  public:
  void clear_currentindex();
  uint32_t currentindex() const;
  void set_currentindex(uint32_t value);
  private:
  uint32_t _internal_currentindex() const;
  void _internal_set_currentindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ADVKeyIndexList)
 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< uint32_t > validindexes_;
    mutable std::atomic<int> _validindexes_cached_byte_size_;
    uint64_t timestamp_;
    uint32_t rawid_;
    uint32_t currentindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ADVSignedDeviceIdentity* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADVSignedDeviceIdentity>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADVSignedDeviceIdentity& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADVSignedDeviceIdentity& from) {
    ADVSignedDeviceIdentity::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDetailsFieldNumber = 1,
    kAccountSignatureKeyFieldNumber = 2,
    kAccountSignatureFieldNumber = 3,
    kDeviceSignatureFieldNumber = 4,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes accountSignatureKey = 2;
  bool has_accountsignaturekey() const;
  private:
  bool _internal_has_accountsignaturekey() const;
  public:
  void clear_accountsignaturekey();
  const std::string& accountsignaturekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_accountsignaturekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_accountsignaturekey();
  PROTOBUF_NODISCARD std::string* release_accountsignaturekey();
  void set_allocated_accountsignaturekey(std::string* accountsignaturekey);
  private:
  const std::string& _internal_accountsignaturekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignaturekey(const std::string& value);
  std::string* _internal_mutable_accountsignaturekey();
  public:

  // optional bytes accountSignature = 3;
  bool has_accountsignature() const;
  private:
  bool _internal_has_accountsignature() const;
  public:
  void clear_accountsignature();
  const std::string& accountsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_accountsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_accountsignature();
  PROTOBUF_NODISCARD std::string* release_accountsignature();
  void set_allocated_accountsignature(std::string* accountsignature);
  private:
  const std::string& _internal_accountsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value);
  std::string* _internal_mutable_accountsignature();
  public:

  // optional bytes deviceSignature = 4;
  bool has_devicesignature() const;
  private:
  bool _internal_has_devicesignature() const;
  public:
  void clear_devicesignature();
  const std::string& devicesignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_devicesignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_devicesignature();
  PROTOBUF_NODISCARD std::string* release_devicesignature();
  void set_allocated_devicesignature(std::string* devicesignature);
  private:
  const std::string& _internal_devicesignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicesignature(const std::string& value);
  std::string* _internal_mutable_devicesignature();
  public:

  // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentity)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignaturekey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr devicesignature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ADVSignedDeviceIdentityHMAC* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADVSignedDeviceIdentityHMAC>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADVSignedDeviceIdentityHMAC& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADVSignedDeviceIdentityHMAC& from) {
    ADVSignedDeviceIdentityHMAC::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDetailsFieldNumber = 1,
    kHmacFieldNumber = 2,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes hmac = 2;
  bool has_hmac() const;
  private:
  bool _internal_has_hmac() const;
  public:
  void clear_hmac();
  const std::string& hmac() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hmac(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hmac();
  PROTOBUF_NODISCARD std::string* release_hmac();
  void set_allocated_hmac(std::string* hmac);
  private:
  const std::string& _internal_hmac() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hmac(const std::string& value);
  std::string* _internal_mutable_hmac();
  public:

  // @@protoc_insertion_point(class_scope:proto.ADVSignedDeviceIdentityHMAC)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hmac_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ADVSignedKeyIndexList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ADVSignedKeyIndexList>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ADVSignedKeyIndexList& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ADVSignedKeyIndexList& from) {
    ADVSignedKeyIndexList::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDetailsFieldNumber = 1,
    kAccountSignatureFieldNumber = 2,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes accountSignature = 2;
  bool has_accountsignature() const;
  private:
  bool _internal_has_accountsignature() const;
  public:
  void clear_accountsignature();
  const std::string& accountsignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_accountsignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_accountsignature();
  PROTOBUF_NODISCARD std::string* release_accountsignature();
  void set_allocated_accountsignature(std::string* accountsignature);
  private:
  const std::string& _internal_accountsignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_accountsignature(const std::string& value);
  std::string* _internal_mutable_accountsignature();
  public:

  // @@protoc_insertion_point(class_scope:proto.ADVSignedKeyIndexList)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr accountsignature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ActionLink* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ActionLink>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ActionLink& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ActionLink& from) {
    ActionLink::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kUrlFieldNumber = 1,
    kButtonTitleFieldNumber = 2,
  };
  // optional 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 buttonTitle = 2;
  bool has_buttontitle() const;
  private:
  bool _internal_has_buttontitle() const;
  public:
  void clear_buttontitle();
  const std::string& buttontitle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_buttontitle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_buttontitle();
  PROTOBUF_NODISCARD std::string* release_buttontitle();
  void set_allocated_buttontitle(std::string* buttontitle);
  private:
  const std::string& _internal_buttontitle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontitle(const std::string& value);
  std::string* _internal_mutable_buttontitle();
  public:

  // @@protoc_insertion_point(class_scope:proto.ActionLink)
 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 buttontitle_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  AutoDownloadSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AutoDownloadSettings>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AutoDownloadSettings& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const AutoDownloadSettings& from) {
    AutoDownloadSettings::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDownloadImagesFieldNumber = 1,
    kDownloadAudioFieldNumber = 2,
    kDownloadVideoFieldNumber = 3,
    kDownloadDocumentsFieldNumber = 4,
  };
  // optional bool downloadImages = 1;
  bool has_downloadimages() const;
  private:
  bool _internal_has_downloadimages() const;
  public:
  void clear_downloadimages();
  bool downloadimages() const;
  void set_downloadimages(bool value);
  private:
  bool _internal_downloadimages() const;
  void _internal_set_downloadimages(bool value);
  public:

  // optional bool downloadAudio = 2;
  bool has_downloadaudio() const;
  private:
  bool _internal_has_downloadaudio() const;
  public:
  void clear_downloadaudio();
  bool downloadaudio() const;
  void set_downloadaudio(bool value);
  private:
  bool _internal_downloadaudio() const;
  void _internal_set_downloadaudio(bool value);
  public:

  // optional bool downloadVideo = 3;
  bool has_downloadvideo() const;
  private:
  bool _internal_has_downloadvideo() const;
  public:
  void clear_downloadvideo();
  bool downloadvideo() const;
  void set_downloadvideo(bool value);
  private:
  bool _internal_downloadvideo() const;
  void _internal_set_downloadvideo(bool value);
  public:

  // optional bool downloadDocuments = 4;
  bool has_downloaddocuments() const;
  private:
  bool _internal_has_downloaddocuments() const;
  public:
  void clear_downloaddocuments();
  bool downloaddocuments() const;
  void set_downloaddocuments(bool value);
  private:
  bool _internal_downloaddocuments() const;
  void _internal_set_downloaddocuments(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.AutoDownloadSettings)
 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 downloadimages_;
    bool downloadaudio_;
    bool downloadvideo_;
    bool downloaddocuments_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  BizAccountLinkInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BizAccountLinkInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BizAccountLinkInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BizAccountLinkInfo& from) {
    BizAccountLinkInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef BizAccountLinkInfo_AccountType AccountType;
  static constexpr AccountType ENTERPRISE =
    BizAccountLinkInfo_AccountType_ENTERPRISE;
  static inline bool AccountType_IsValid(int value) {
    return BizAccountLinkInfo_AccountType_IsValid(value);
  }
  static constexpr AccountType AccountType_MIN =
    BizAccountLinkInfo_AccountType_AccountType_MIN;
  static constexpr AccountType AccountType_MAX =
    BizAccountLinkInfo_AccountType_AccountType_MAX;
  static constexpr int AccountType_ARRAYSIZE =
    BizAccountLinkInfo_AccountType_AccountType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  AccountType_descriptor() {
    return BizAccountLinkInfo_AccountType_descriptor();
  }
  template<typename T>
  static inline const std::string& AccountType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AccountType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AccountType_Name.");
    return BizAccountLinkInfo_AccountType_Name(enum_t_value);
  }
  static inline bool AccountType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AccountType* value) {
    return BizAccountLinkInfo_AccountType_Parse(name, value);
  }

  typedef BizAccountLinkInfo_HostStorageType HostStorageType;
  static constexpr HostStorageType ON_PREMISE =
    BizAccountLinkInfo_HostStorageType_ON_PREMISE;
  static constexpr HostStorageType FACEBOOK =
    BizAccountLinkInfo_HostStorageType_FACEBOOK;
  static inline bool HostStorageType_IsValid(int value) {
    return BizAccountLinkInfo_HostStorageType_IsValid(value);
  }
  static constexpr HostStorageType HostStorageType_MIN =
    BizAccountLinkInfo_HostStorageType_HostStorageType_MIN;
  static constexpr HostStorageType HostStorageType_MAX =
    BizAccountLinkInfo_HostStorageType_HostStorageType_MAX;
  static constexpr int HostStorageType_ARRAYSIZE =
    BizAccountLinkInfo_HostStorageType_HostStorageType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HostStorageType_descriptor() {
    return BizAccountLinkInfo_HostStorageType_descriptor();
  }
  template<typename T>
  static inline const std::string& HostStorageType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HostStorageType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HostStorageType_Name.");
    return BizAccountLinkInfo_HostStorageType_Name(enum_t_value);
  }
  static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HostStorageType* value) {
    return BizAccountLinkInfo_HostStorageType_Parse(name, value);
  }

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

  enum : int {
    kWhatsappAcctNumberFieldNumber = 2,
    kWhatsappBizAcctFbidFieldNumber = 1,
    kIssueTimeFieldNumber = 3,
    kHostStorageFieldNumber = 4,
    kAccountTypeFieldNumber = 5,
  };
  // optional string whatsappAcctNumber = 2;
  bool has_whatsappacctnumber() const;
  private:
  bool _internal_has_whatsappacctnumber() const;
  public:
  void clear_whatsappacctnumber();
  const std::string& whatsappacctnumber() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_whatsappacctnumber(ArgT0&& arg0, ArgT... args);
  std::string* mutable_whatsappacctnumber();
  PROTOBUF_NODISCARD std::string* release_whatsappacctnumber();
  void set_allocated_whatsappacctnumber(std::string* whatsappacctnumber);
  private:
  const std::string& _internal_whatsappacctnumber() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_whatsappacctnumber(const std::string& value);
  std::string* _internal_mutable_whatsappacctnumber();
  public:

  // optional uint64 whatsappBizAcctFbid = 1;
  bool has_whatsappbizacctfbid() const;
  private:
  bool _internal_has_whatsappbizacctfbid() const;
  public:
  void clear_whatsappbizacctfbid();
  uint64_t whatsappbizacctfbid() const;
  void set_whatsappbizacctfbid(uint64_t value);
  private:
  uint64_t _internal_whatsappbizacctfbid() const;
  void _internal_set_whatsappbizacctfbid(uint64_t value);
  public:

  // optional uint64 issueTime = 3;
  bool has_issuetime() const;
  private:
  bool _internal_has_issuetime() const;
  public:
  void clear_issuetime();
  uint64_t issuetime() const;
  void set_issuetime(uint64_t value);
  private:
  uint64_t _internal_issuetime() const;
  void _internal_set_issuetime(uint64_t value);
  public:

  // optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
  bool has_hoststorage() const;
  private:
  bool _internal_has_hoststorage() const;
  public:
  void clear_hoststorage();
  ::proto::BizAccountLinkInfo_HostStorageType hoststorage() const;
  void set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value);
  private:
  ::proto::BizAccountLinkInfo_HostStorageType _internal_hoststorage() const;
  void _internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value);
  public:

  // optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
  bool has_accounttype() const;
  private:
  bool _internal_has_accounttype() const;
  public:
  void clear_accounttype();
  ::proto::BizAccountLinkInfo_AccountType accounttype() const;
  void set_accounttype(::proto::BizAccountLinkInfo_AccountType value);
  private:
  ::proto::BizAccountLinkInfo_AccountType _internal_accounttype() const;
  void _internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.BizAccountLinkInfo)
 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 whatsappacctnumber_;
    uint64_t whatsappbizacctfbid_;
    uint64_t issuetime_;
    int hoststorage_;
    int accounttype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  BizAccountPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BizAccountPayload>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BizAccountPayload& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BizAccountPayload& from) {
    BizAccountPayload::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kBizAcctLinkInfoFieldNumber = 2,
    kVnameCertFieldNumber = 1,
  };
  // optional bytes bizAcctLinkInfo = 2;
  bool has_bizacctlinkinfo() const;
  private:
  bool _internal_has_bizacctlinkinfo() const;
  public:
  void clear_bizacctlinkinfo();
  const std::string& bizacctlinkinfo() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bizacctlinkinfo();
  PROTOBUF_NODISCARD std::string* release_bizacctlinkinfo();
  void set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo);
  private:
  const std::string& _internal_bizacctlinkinfo() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizacctlinkinfo(const std::string& value);
  std::string* _internal_mutable_bizacctlinkinfo();
  public:

  // optional .proto.VerifiedNameCertificate vnameCert = 1;
  bool has_vnamecert() const;
  private:
  bool _internal_has_vnamecert() const;
  public:
  void clear_vnamecert();
  const ::proto::VerifiedNameCertificate& vnamecert() const;
  PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert();
  ::proto::VerifiedNameCertificate* mutable_vnamecert();
  void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert);
  private:
  const ::proto::VerifiedNameCertificate& _internal_vnamecert() const;
  ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert();
  public:
  void unsafe_arena_set_allocated_vnamecert(
      ::proto::VerifiedNameCertificate* vnamecert);
  ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert();

  // @@protoc_insertion_point(class_scope:proto.BizAccountPayload)
 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 bizacctlinkinfo_;
    ::proto::VerifiedNameCertificate* vnamecert_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  BizIdentityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BizIdentityInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BizIdentityInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const BizIdentityInfo& from) {
    BizIdentityInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef BizIdentityInfo_ActualActorsType ActualActorsType;
  static constexpr ActualActorsType SELF =
    BizIdentityInfo_ActualActorsType_SELF;
  static constexpr ActualActorsType BSP =
    BizIdentityInfo_ActualActorsType_BSP;
  static inline bool ActualActorsType_IsValid(int value) {
    return BizIdentityInfo_ActualActorsType_IsValid(value);
  }
  static constexpr ActualActorsType ActualActorsType_MIN =
    BizIdentityInfo_ActualActorsType_ActualActorsType_MIN;
  static constexpr ActualActorsType ActualActorsType_MAX =
    BizIdentityInfo_ActualActorsType_ActualActorsType_MAX;
  static constexpr int ActualActorsType_ARRAYSIZE =
    BizIdentityInfo_ActualActorsType_ActualActorsType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ActualActorsType_descriptor() {
    return BizIdentityInfo_ActualActorsType_descriptor();
  }
  template<typename T>
  static inline const std::string& ActualActorsType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ActualActorsType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ActualActorsType_Name.");
    return BizIdentityInfo_ActualActorsType_Name(enum_t_value);
  }
  static inline bool ActualActorsType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ActualActorsType* value) {
    return BizIdentityInfo_ActualActorsType_Parse(name, value);
  }

  typedef BizIdentityInfo_HostStorageType HostStorageType;
  static constexpr HostStorageType ON_PREMISE =
    BizIdentityInfo_HostStorageType_ON_PREMISE;
  static constexpr HostStorageType FACEBOOK =
    BizIdentityInfo_HostStorageType_FACEBOOK;
  static inline bool HostStorageType_IsValid(int value) {
    return BizIdentityInfo_HostStorageType_IsValid(value);
  }
  static constexpr HostStorageType HostStorageType_MIN =
    BizIdentityInfo_HostStorageType_HostStorageType_MIN;
  static constexpr HostStorageType HostStorageType_MAX =
    BizIdentityInfo_HostStorageType_HostStorageType_MAX;
  static constexpr int HostStorageType_ARRAYSIZE =
    BizIdentityInfo_HostStorageType_HostStorageType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HostStorageType_descriptor() {
    return BizIdentityInfo_HostStorageType_descriptor();
  }
  template<typename T>
  static inline const std::string& HostStorageType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HostStorageType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HostStorageType_Name.");
    return BizIdentityInfo_HostStorageType_Name(enum_t_value);
  }
  static inline bool HostStorageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HostStorageType* value) {
    return BizIdentityInfo_HostStorageType_Parse(name, value);
  }

  typedef BizIdentityInfo_VerifiedLevelValue VerifiedLevelValue;
  static constexpr VerifiedLevelValue UNKNOWN =
    BizIdentityInfo_VerifiedLevelValue_UNKNOWN;
  static constexpr VerifiedLevelValue LOW =
    BizIdentityInfo_VerifiedLevelValue_LOW;
  static constexpr VerifiedLevelValue HIGH =
    BizIdentityInfo_VerifiedLevelValue_HIGH;
  static inline bool VerifiedLevelValue_IsValid(int value) {
    return BizIdentityInfo_VerifiedLevelValue_IsValid(value);
  }
  static constexpr VerifiedLevelValue VerifiedLevelValue_MIN =
    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MIN;
  static constexpr VerifiedLevelValue VerifiedLevelValue_MAX =
    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_MAX;
  static constexpr int VerifiedLevelValue_ARRAYSIZE =
    BizIdentityInfo_VerifiedLevelValue_VerifiedLevelValue_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  VerifiedLevelValue_descriptor() {
    return BizIdentityInfo_VerifiedLevelValue_descriptor();
  }
  template<typename T>
  static inline const std::string& VerifiedLevelValue_Name(T enum_t_value) {
    static_assert(::std::is_same<T, VerifiedLevelValue>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function VerifiedLevelValue_Name.");
    return BizIdentityInfo_VerifiedLevelValue_Name(enum_t_value);
  }
  static inline bool VerifiedLevelValue_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      VerifiedLevelValue* value) {
    return BizIdentityInfo_VerifiedLevelValue_Parse(name, value);
  }

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

  enum : int {
    kVnameCertFieldNumber = 2,
    kVlevelFieldNumber = 1,
    kSignedFieldNumber = 3,
    kRevokedFieldNumber = 4,
    kHostStorageFieldNumber = 5,
    kActualActorsFieldNumber = 6,
    kPrivacyModeTsFieldNumber = 7,
    kFeatureControlsFieldNumber = 8,
  };
  // optional .proto.VerifiedNameCertificate vnameCert = 2;
  bool has_vnamecert() const;
  private:
  bool _internal_has_vnamecert() const;
  public:
  void clear_vnamecert();
  const ::proto::VerifiedNameCertificate& vnamecert() const;
  PROTOBUF_NODISCARD ::proto::VerifiedNameCertificate* release_vnamecert();
  ::proto::VerifiedNameCertificate* mutable_vnamecert();
  void set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert);
  private:
  const ::proto::VerifiedNameCertificate& _internal_vnamecert() const;
  ::proto::VerifiedNameCertificate* _internal_mutable_vnamecert();
  public:
  void unsafe_arena_set_allocated_vnamecert(
      ::proto::VerifiedNameCertificate* vnamecert);
  ::proto::VerifiedNameCertificate* unsafe_arena_release_vnamecert();

  // optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
  bool has_vlevel() const;
  private:
  bool _internal_has_vlevel() const;
  public:
  void clear_vlevel();
  ::proto::BizIdentityInfo_VerifiedLevelValue vlevel() const;
  void set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value);
  private:
  ::proto::BizIdentityInfo_VerifiedLevelValue _internal_vlevel() const;
  void _internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value);
  public:

  // optional bool signed = 3;
  bool has_signed_() const;
  private:
  bool _internal_has_signed_() const;
  public:
  void clear_signed_();
  bool signed_() const;
  void set_signed_(bool value);
  private:
  bool _internal_signed_() const;
  void _internal_set_signed_(bool value);
  public:

  // optional bool revoked = 4;
  bool has_revoked() const;
  private:
  bool _internal_has_revoked() const;
  public:
  void clear_revoked();
  bool revoked() const;
  void set_revoked(bool value);
  private:
  bool _internal_revoked() const;
  void _internal_set_revoked(bool value);
  public:

  // optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
  bool has_hoststorage() const;
  private:
  bool _internal_has_hoststorage() const;
  public:
  void clear_hoststorage();
  ::proto::BizIdentityInfo_HostStorageType hoststorage() const;
  void set_hoststorage(::proto::BizIdentityInfo_HostStorageType value);
  private:
  ::proto::BizIdentityInfo_HostStorageType _internal_hoststorage() const;
  void _internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value);
  public:

  // optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
  bool has_actualactors() const;
  private:
  bool _internal_has_actualactors() const;
  public:
  void clear_actualactors();
  ::proto::BizIdentityInfo_ActualActorsType actualactors() const;
  void set_actualactors(::proto::BizIdentityInfo_ActualActorsType value);
  private:
  ::proto::BizIdentityInfo_ActualActorsType _internal_actualactors() const;
  void _internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value);
  public:

  // optional uint64 privacyModeTs = 7;
  bool has_privacymodets() const;
  private:
  bool _internal_has_privacymodets() const;
  public:
  void clear_privacymodets();
  uint64_t privacymodets() const;
  void set_privacymodets(uint64_t value);
  private:
  uint64_t _internal_privacymodets() const;
  void _internal_set_privacymodets(uint64_t value);
  public:

  // optional uint64 featureControls = 8;
  bool has_featurecontrols() const;
  private:
  bool _internal_has_featurecontrols() const;
  public:
  void clear_featurecontrols();
  uint64_t featurecontrols() const;
  void set_featurecontrols(uint64_t value);
  private:
  uint64_t _internal_featurecontrols() const;
  void _internal_set_featurecontrols(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.BizIdentityInfo)
 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_;
    ::proto::VerifiedNameCertificate* vnamecert_;
    int vlevel_;
    bool signed__;
    bool revoked_;
    int hoststorage_;
    int actualactors_;
    uint64_t privacymodets_;
    uint64_t featurecontrols_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class CertChain_NoiseCertificate_Details final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate.Details) */ {
 public:
  inline CertChain_NoiseCertificate_Details() : CertChain_NoiseCertificate_Details(nullptr) {}
  ~CertChain_NoiseCertificate_Details() override;
  explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  CertChain_NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CertChain_NoiseCertificate_Details>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CertChain_NoiseCertificate_Details& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CertChain_NoiseCertificate_Details& from) {
    CertChain_NoiseCertificate_Details::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyFieldNumber = 3,
    kSerialFieldNumber = 1,
    kIssuerSerialFieldNumber = 2,
    kNotBeforeFieldNumber = 4,
    kNotAfterFieldNumber = 5,
  };
  // 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 uint32 serial = 1;
  bool has_serial() const;
  private:
  bool _internal_has_serial() const;
  public:
  void clear_serial();
  uint32_t serial() const;
  void set_serial(uint32_t value);
  private:
  uint32_t _internal_serial() const;
  void _internal_set_serial(uint32_t value);
  public:

  // optional uint32 issuerSerial = 2;
  bool has_issuerserial() const;
  private:
  bool _internal_has_issuerserial() const;
  public:
  void clear_issuerserial();
  uint32_t issuerserial() const;
  void set_issuerserial(uint32_t value);
  private:
  uint32_t _internal_issuerserial() const;
  void _internal_set_issuerserial(uint32_t value);
  public:

  // optional uint64 notBefore = 4;
  bool has_notbefore() const;
  private:
  bool _internal_has_notbefore() const;
  public:
  void clear_notbefore();
  uint64_t notbefore() const;
  void set_notbefore(uint64_t value);
  private:
  uint64_t _internal_notbefore() const;
  void _internal_set_notbefore(uint64_t value);
  public:

  // optional uint64 notAfter = 5;
  bool has_notafter() const;
  private:
  bool _internal_has_notafter() const;
  public:
  void clear_notafter();
  uint64_t notafter() const;
  void set_notafter(uint64_t value);
  private:
  uint64_t _internal_notafter() const;
  void _internal_set_notafter(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate.Details)
 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 key_;
    uint32_t serial_;
    uint32_t issuerserial_;
    uint64_t notbefore_;
    uint64_t notafter_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class CertChain_NoiseCertificate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.CertChain.NoiseCertificate) */ {
 public:
  inline CertChain_NoiseCertificate() : CertChain_NoiseCertificate(nullptr) {}
  ~CertChain_NoiseCertificate() override;
  explicit PROTOBUF_CONSTEXPR CertChain_NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  CertChain_NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CertChain_NoiseCertificate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CertChain_NoiseCertificate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CertChain_NoiseCertificate& from) {
    CertChain_NoiseCertificate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef CertChain_NoiseCertificate_Details Details;

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

  enum : int {
    kDetailsFieldNumber = 1,
    kSignatureFieldNumber = 2,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_NODISCARD std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // @@protoc_insertion_point(class_scope:proto.CertChain.NoiseCertificate)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  CertChain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CertChain>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CertChain& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CertChain& from) {
    CertChain::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef CertChain_NoiseCertificate NoiseCertificate;

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

  enum : int {
    kLeafFieldNumber = 1,
    kIntermediateFieldNumber = 2,
  };
  // optional .proto.CertChain.NoiseCertificate leaf = 1;
  bool has_leaf() const;
  private:
  bool _internal_has_leaf() const;
  public:
  void clear_leaf();
  const ::proto::CertChain_NoiseCertificate& leaf() const;
  PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_leaf();
  ::proto::CertChain_NoiseCertificate* mutable_leaf();
  void set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf);
  private:
  const ::proto::CertChain_NoiseCertificate& _internal_leaf() const;
  ::proto::CertChain_NoiseCertificate* _internal_mutable_leaf();
  public:
  void unsafe_arena_set_allocated_leaf(
      ::proto::CertChain_NoiseCertificate* leaf);
  ::proto::CertChain_NoiseCertificate* unsafe_arena_release_leaf();

  // optional .proto.CertChain.NoiseCertificate intermediate = 2;
  bool has_intermediate() const;
  private:
  bool _internal_has_intermediate() const;
  public:
  void clear_intermediate();
  const ::proto::CertChain_NoiseCertificate& intermediate() const;
  PROTOBUF_NODISCARD ::proto::CertChain_NoiseCertificate* release_intermediate();
  ::proto::CertChain_NoiseCertificate* mutable_intermediate();
  void set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate);
  private:
  const ::proto::CertChain_NoiseCertificate& _internal_intermediate() const;
  ::proto::CertChain_NoiseCertificate* _internal_mutable_intermediate();
  public:
  void unsafe_arena_set_allocated_intermediate(
      ::proto::CertChain_NoiseCertificate* intermediate);
  ::proto::CertChain_NoiseCertificate* unsafe_arena_release_intermediate();

  // @@protoc_insertion_point(class_scope:proto.CertChain)
 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_;
    ::proto::CertChain_NoiseCertificate* leaf_;
    ::proto::CertChain_NoiseCertificate* intermediate_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Chain* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Chain>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Chain& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Chain& from) {
    Chain::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kMessageKeysFieldNumber = 4,
    kSenderRatchetKeyFieldNumber = 1,
    kSenderRatchetKeyPrivateFieldNumber = 2,
    kChainKeyFieldNumber = 3,
  };
  // repeated .proto.MessageKey messageKeys = 4;
  int messagekeys_size() const;
  private:
  int _internal_messagekeys_size() const;
  public:
  void clear_messagekeys();
  ::proto::MessageKey* mutable_messagekeys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >*
      mutable_messagekeys();
  private:
  const ::proto::MessageKey& _internal_messagekeys(int index) const;
  ::proto::MessageKey* _internal_add_messagekeys();
  public:
  const ::proto::MessageKey& messagekeys(int index) const;
  ::proto::MessageKey* add_messagekeys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >&
      messagekeys() const;

  // optional bytes senderRatchetKey = 1;
  bool has_senderratchetkey() const;
  private:
  bool _internal_has_senderratchetkey() const;
  public:
  void clear_senderratchetkey();
  const std::string& senderratchetkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_senderratchetkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_senderratchetkey();
  PROTOBUF_NODISCARD std::string* release_senderratchetkey();
  void set_allocated_senderratchetkey(std::string* senderratchetkey);
  private:
  const std::string& _internal_senderratchetkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkey(const std::string& value);
  std::string* _internal_mutable_senderratchetkey();
  public:

  // optional bytes senderRatchetKeyPrivate = 2;
  bool has_senderratchetkeyprivate() const;
  private:
  bool _internal_has_senderratchetkeyprivate() const;
  public:
  void clear_senderratchetkeyprivate();
  const std::string& senderratchetkeyprivate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_senderratchetkeyprivate();
  PROTOBUF_NODISCARD std::string* release_senderratchetkeyprivate();
  void set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate);
  private:
  const std::string& _internal_senderratchetkeyprivate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderratchetkeyprivate(const std::string& value);
  std::string* _internal_mutable_senderratchetkeyprivate();
  public:

  // optional .proto.ChainKey chainKey = 3;
  bool has_chainkey() const;
  private:
  bool _internal_has_chainkey() const;
  public:
  void clear_chainkey();
  const ::proto::ChainKey& chainkey() const;
  PROTOBUF_NODISCARD ::proto::ChainKey* release_chainkey();
  ::proto::ChainKey* mutable_chainkey();
  void set_allocated_chainkey(::proto::ChainKey* chainkey);
  private:
  const ::proto::ChainKey& _internal_chainkey() const;
  ::proto::ChainKey* _internal_mutable_chainkey();
  public:
  void unsafe_arena_set_allocated_chainkey(
      ::proto::ChainKey* chainkey);
  ::proto::ChainKey* unsafe_arena_release_chainkey();

  // @@protoc_insertion_point(class_scope:proto.Chain)
 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< ::proto::MessageKey > messagekeys_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderratchetkeyprivate_;
    ::proto::ChainKey* chainkey_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ChainKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ChainKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ChainKey& from) {
    ChainKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyFieldNumber = 2,
    kIndexFieldNumber = 1,
  };
  // optional bytes key = 2;
  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 uint32 index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ChainKey)
 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 key_;
    uint32_t index_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_DNSSource final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DNSSource) */ {
 public:
  inline ClientPayload_DNSSource() : ClientPayload_DNSSource(nullptr) {}
  ~ClientPayload_DNSSource() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_DNSSource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_DNSSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_DNSSource>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_DNSSource& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_DNSSource& from) {
    ClientPayload_DNSSource::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ClientPayload_DNSSource_DNSResolutionMethod DNSResolutionMethod;
  static constexpr DNSResolutionMethod SYSTEM =
    ClientPayload_DNSSource_DNSResolutionMethod_SYSTEM;
  static constexpr DNSResolutionMethod GOOGLE =
    ClientPayload_DNSSource_DNSResolutionMethod_GOOGLE;
  static constexpr DNSResolutionMethod HARDCODED =
    ClientPayload_DNSSource_DNSResolutionMethod_HARDCODED;
  static constexpr DNSResolutionMethod OVERRIDE =
    ClientPayload_DNSSource_DNSResolutionMethod_OVERRIDE;
  static constexpr DNSResolutionMethod FALLBACK =
    ClientPayload_DNSSource_DNSResolutionMethod_FALLBACK;
  static inline bool DNSResolutionMethod_IsValid(int value) {
    return ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value);
  }
  static constexpr DNSResolutionMethod DNSResolutionMethod_MIN =
    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MIN;
  static constexpr DNSResolutionMethod DNSResolutionMethod_MAX =
    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_MAX;
  static constexpr int DNSResolutionMethod_ARRAYSIZE =
    ClientPayload_DNSSource_DNSResolutionMethod_DNSResolutionMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DNSResolutionMethod_descriptor() {
    return ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& DNSResolutionMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DNSResolutionMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DNSResolutionMethod_Name.");
    return ClientPayload_DNSSource_DNSResolutionMethod_Name(enum_t_value);
  }
  static inline bool DNSResolutionMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DNSResolutionMethod* value) {
    return ClientPayload_DNSSource_DNSResolutionMethod_Parse(name, value);
  }

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

  enum : int {
    kDnsMethodFieldNumber = 15,
    kAppCachedFieldNumber = 16,
  };
  // optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
  bool has_dnsmethod() const;
  private:
  bool _internal_has_dnsmethod() const;
  public:
  void clear_dnsmethod();
  ::proto::ClientPayload_DNSSource_DNSResolutionMethod dnsmethod() const;
  void set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value);
  private:
  ::proto::ClientPayload_DNSSource_DNSResolutionMethod _internal_dnsmethod() const;
  void _internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value);
  public:

  // optional bool appCached = 16;
  bool has_appcached() const;
  private:
  bool _internal_has_appcached() const;
  public:
  void clear_appcached();
  bool appcached() const;
  void set_appcached(bool value);
  private:
  bool _internal_appcached() const;
  void _internal_set_appcached(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.DNSSource)
 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_;
    int dnsmethod_;
    bool appcached_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_DevicePairingRegistrationData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.DevicePairingRegistrationData) */ {
 public:
  inline ClientPayload_DevicePairingRegistrationData() : ClientPayload_DevicePairingRegistrationData(nullptr) {}
  ~ClientPayload_DevicePairingRegistrationData() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_DevicePairingRegistrationData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_DevicePairingRegistrationData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_DevicePairingRegistrationData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_DevicePairingRegistrationData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_DevicePairingRegistrationData& from) {
    ClientPayload_DevicePairingRegistrationData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kERegidFieldNumber = 1,
    kEKeytypeFieldNumber = 2,
    kEIdentFieldNumber = 3,
    kESkeyIdFieldNumber = 4,
    kESkeyValFieldNumber = 5,
    kESkeySigFieldNumber = 6,
    kBuildHashFieldNumber = 7,
    kDevicePropsFieldNumber = 8,
  };
  // optional bytes eRegid = 1;
  bool has_eregid() const;
  private:
  bool _internal_has_eregid() const;
  public:
  void clear_eregid();
  const std::string& eregid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eregid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eregid();
  PROTOBUF_NODISCARD std::string* release_eregid();
  void set_allocated_eregid(std::string* eregid);
  private:
  const std::string& _internal_eregid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eregid(const std::string& value);
  std::string* _internal_mutable_eregid();
  public:

  // optional bytes eKeytype = 2;
  bool has_ekeytype() const;
  private:
  bool _internal_has_ekeytype() const;
  public:
  void clear_ekeytype();
  const std::string& ekeytype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ekeytype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ekeytype();
  PROTOBUF_NODISCARD std::string* release_ekeytype();
  void set_allocated_ekeytype(std::string* ekeytype);
  private:
  const std::string& _internal_ekeytype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ekeytype(const std::string& value);
  std::string* _internal_mutable_ekeytype();
  public:

  // optional bytes eIdent = 3;
  bool has_eident() const;
  private:
  bool _internal_has_eident() const;
  public:
  void clear_eident();
  const std::string& eident() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eident(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eident();
  PROTOBUF_NODISCARD std::string* release_eident();
  void set_allocated_eident(std::string* eident);
  private:
  const std::string& _internal_eident() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eident(const std::string& value);
  std::string* _internal_mutable_eident();
  public:

  // optional bytes eSkeyId = 4;
  bool has_eskeyid() const;
  private:
  bool _internal_has_eskeyid() const;
  public:
  void clear_eskeyid();
  const std::string& eskeyid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eskeyid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eskeyid();
  PROTOBUF_NODISCARD std::string* release_eskeyid();
  void set_allocated_eskeyid(std::string* eskeyid);
  private:
  const std::string& _internal_eskeyid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyid(const std::string& value);
  std::string* _internal_mutable_eskeyid();
  public:

  // optional bytes eSkeyVal = 5;
  bool has_eskeyval() const;
  private:
  bool _internal_has_eskeyval() const;
  public:
  void clear_eskeyval();
  const std::string& eskeyval() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eskeyval(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eskeyval();
  PROTOBUF_NODISCARD std::string* release_eskeyval();
  void set_allocated_eskeyval(std::string* eskeyval);
  private:
  const std::string& _internal_eskeyval() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeyval(const std::string& value);
  std::string* _internal_mutable_eskeyval();
  public:

  // optional bytes eSkeySig = 6;
  bool has_eskeysig() const;
  private:
  bool _internal_has_eskeysig() const;
  public:
  void clear_eskeysig();
  const std::string& eskeysig() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_eskeysig(ArgT0&& arg0, ArgT... args);
  std::string* mutable_eskeysig();
  PROTOBUF_NODISCARD std::string* release_eskeysig();
  void set_allocated_eskeysig(std::string* eskeysig);
  private:
  const std::string& _internal_eskeysig() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_eskeysig(const std::string& value);
  std::string* _internal_mutable_eskeysig();
  public:

  // optional bytes buildHash = 7;
  bool has_buildhash() const;
  private:
  bool _internal_has_buildhash() const;
  public:
  void clear_buildhash();
  const std::string& buildhash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_buildhash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_buildhash();
  PROTOBUF_NODISCARD std::string* release_buildhash();
  void set_allocated_buildhash(std::string* buildhash);
  private:
  const std::string& _internal_buildhash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buildhash(const std::string& value);
  std::string* _internal_mutable_buildhash();
  public:

  // optional bytes deviceProps = 8;
  bool has_deviceprops() const;
  private:
  bool _internal_has_deviceprops() const;
  public:
  void clear_deviceprops();
  const std::string& deviceprops() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_deviceprops(ArgT0&& arg0, ArgT... args);
  std::string* mutable_deviceprops();
  PROTOBUF_NODISCARD std::string* release_deviceprops();
  void set_allocated_deviceprops(std::string* deviceprops);
  private:
  const std::string& _internal_deviceprops() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceprops(const std::string& value);
  std::string* _internal_mutable_deviceprops();
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.DevicePairingRegistrationData)
 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 eregid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ekeytype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eident_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeyval_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr eskeysig_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buildhash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceprops_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_UserAgent_AppVersion final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent.AppVersion) */ {
 public:
  inline ClientPayload_UserAgent_AppVersion() : ClientPayload_UserAgent_AppVersion(nullptr) {}
  ~ClientPayload_UserAgent_AppVersion() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_UserAgent_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_UserAgent_AppVersion>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_UserAgent_AppVersion& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_UserAgent_AppVersion& from) {
    ClientPayload_UserAgent_AppVersion::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kPrimaryFieldNumber = 1,
    kSecondaryFieldNumber = 2,
    kTertiaryFieldNumber = 3,
    kQuaternaryFieldNumber = 4,
    kQuinaryFieldNumber = 5,
  };
  // optional uint32 primary = 1;
  bool has_primary() const;
  private:
  bool _internal_has_primary() const;
  public:
  void clear_primary();
  uint32_t primary() const;
  void set_primary(uint32_t value);
  private:
  uint32_t _internal_primary() const;
  void _internal_set_primary(uint32_t value);
  public:

  // optional uint32 secondary = 2;
  bool has_secondary() const;
  private:
  bool _internal_has_secondary() const;
  public:
  void clear_secondary();
  uint32_t secondary() const;
  void set_secondary(uint32_t value);
  private:
  uint32_t _internal_secondary() const;
  void _internal_set_secondary(uint32_t value);
  public:

  // optional uint32 tertiary = 3;
  bool has_tertiary() const;
  private:
  bool _internal_has_tertiary() const;
  public:
  void clear_tertiary();
  uint32_t tertiary() const;
  void set_tertiary(uint32_t value);
  private:
  uint32_t _internal_tertiary() const;
  void _internal_set_tertiary(uint32_t value);
  public:

  // optional uint32 quaternary = 4;
  bool has_quaternary() const;
  private:
  bool _internal_has_quaternary() const;
  public:
  void clear_quaternary();
  uint32_t quaternary() const;
  void set_quaternary(uint32_t value);
  private:
  uint32_t _internal_quaternary() const;
  void _internal_set_quaternary(uint32_t value);
  public:

  // optional uint32 quinary = 5;
  bool has_quinary() const;
  private:
  bool _internal_has_quinary() const;
  public:
  void clear_quinary();
  uint32_t quinary() const;
  void set_quinary(uint32_t value);
  private:
  uint32_t _internal_quinary() const;
  void _internal_set_quinary(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent.AppVersion)
 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_;
    uint32_t primary_;
    uint32_t secondary_;
    uint32_t tertiary_;
    uint32_t quaternary_;
    uint32_t quinary_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_UserAgent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.UserAgent) */ {
 public:
  inline ClientPayload_UserAgent() : ClientPayload_UserAgent(nullptr) {}
  ~ClientPayload_UserAgent() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_UserAgent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_UserAgent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_UserAgent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_UserAgent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_UserAgent& from) {
    ClientPayload_UserAgent::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ClientPayload_UserAgent_AppVersion AppVersion;

  typedef ClientPayload_UserAgent_Platform Platform;
  static constexpr Platform ANDROID =
    ClientPayload_UserAgent_Platform_ANDROID;
  static constexpr Platform IOS =
    ClientPayload_UserAgent_Platform_IOS;
  static constexpr Platform WINDOWS_PHONE =
    ClientPayload_UserAgent_Platform_WINDOWS_PHONE;
  static constexpr Platform BLACKBERRY =
    ClientPayload_UserAgent_Platform_BLACKBERRY;
  static constexpr Platform BLACKBERRYX =
    ClientPayload_UserAgent_Platform_BLACKBERRYX;
  static constexpr Platform S40 =
    ClientPayload_UserAgent_Platform_S40;
  static constexpr Platform S60 =
    ClientPayload_UserAgent_Platform_S60;
  static constexpr Platform PYTHON_CLIENT =
    ClientPayload_UserAgent_Platform_PYTHON_CLIENT;
  static constexpr Platform TIZEN =
    ClientPayload_UserAgent_Platform_TIZEN;
  static constexpr Platform ENTERPRISE =
    ClientPayload_UserAgent_Platform_ENTERPRISE;
  static constexpr Platform SMB_ANDROID =
    ClientPayload_UserAgent_Platform_SMB_ANDROID;
  static constexpr Platform KAIOS =
    ClientPayload_UserAgent_Platform_KAIOS;
  static constexpr Platform SMB_IOS =
    ClientPayload_UserAgent_Platform_SMB_IOS;
  static constexpr Platform WINDOWS =
    ClientPayload_UserAgent_Platform_WINDOWS;
  static constexpr Platform WEB =
    ClientPayload_UserAgent_Platform_WEB;
  static constexpr Platform PORTAL =
    ClientPayload_UserAgent_Platform_PORTAL;
  static constexpr Platform GREEN_ANDROID =
    ClientPayload_UserAgent_Platform_GREEN_ANDROID;
  static constexpr Platform GREEN_IPHONE =
    ClientPayload_UserAgent_Platform_GREEN_IPHONE;
  static constexpr Platform BLUE_ANDROID =
    ClientPayload_UserAgent_Platform_BLUE_ANDROID;
  static constexpr Platform BLUE_IPHONE =
    ClientPayload_UserAgent_Platform_BLUE_IPHONE;
  static constexpr Platform FBLITE_ANDROID =
    ClientPayload_UserAgent_Platform_FBLITE_ANDROID;
  static constexpr Platform MLITE_ANDROID =
    ClientPayload_UserAgent_Platform_MLITE_ANDROID;
  static constexpr Platform IGLITE_ANDROID =
    ClientPayload_UserAgent_Platform_IGLITE_ANDROID;
  static constexpr Platform PAGE =
    ClientPayload_UserAgent_Platform_PAGE;
  static constexpr Platform MACOS =
    ClientPayload_UserAgent_Platform_MACOS;
  static constexpr Platform OCULUS_MSG =
    ClientPayload_UserAgent_Platform_OCULUS_MSG;
  static constexpr Platform OCULUS_CALL =
    ClientPayload_UserAgent_Platform_OCULUS_CALL;
  static constexpr Platform MILAN =
    ClientPayload_UserAgent_Platform_MILAN;
  static constexpr Platform CAPI =
    ClientPayload_UserAgent_Platform_CAPI;
  static inline bool Platform_IsValid(int value) {
    return ClientPayload_UserAgent_Platform_IsValid(value);
  }
  static constexpr Platform Platform_MIN =
    ClientPayload_UserAgent_Platform_Platform_MIN;
  static constexpr Platform Platform_MAX =
    ClientPayload_UserAgent_Platform_Platform_MAX;
  static constexpr int Platform_ARRAYSIZE =
    ClientPayload_UserAgent_Platform_Platform_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Platform_descriptor() {
    return ClientPayload_UserAgent_Platform_descriptor();
  }
  template<typename T>
  static inline const std::string& Platform_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Platform>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Platform_Name.");
    return ClientPayload_UserAgent_Platform_Name(enum_t_value);
  }
  static inline bool Platform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Platform* value) {
    return ClientPayload_UserAgent_Platform_Parse(name, value);
  }

  typedef ClientPayload_UserAgent_ReleaseChannel ReleaseChannel;
  static constexpr ReleaseChannel RELEASE =
    ClientPayload_UserAgent_ReleaseChannel_RELEASE;
  static constexpr ReleaseChannel BETA =
    ClientPayload_UserAgent_ReleaseChannel_BETA;
  static constexpr ReleaseChannel ALPHA =
    ClientPayload_UserAgent_ReleaseChannel_ALPHA;
  static constexpr ReleaseChannel DEBUG =
    ClientPayload_UserAgent_ReleaseChannel_DEBUG;
  static inline bool ReleaseChannel_IsValid(int value) {
    return ClientPayload_UserAgent_ReleaseChannel_IsValid(value);
  }
  static constexpr ReleaseChannel ReleaseChannel_MIN =
    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MIN;
  static constexpr ReleaseChannel ReleaseChannel_MAX =
    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_MAX;
  static constexpr int ReleaseChannel_ARRAYSIZE =
    ClientPayload_UserAgent_ReleaseChannel_ReleaseChannel_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ReleaseChannel_descriptor() {
    return ClientPayload_UserAgent_ReleaseChannel_descriptor();
  }
  template<typename T>
  static inline const std::string& ReleaseChannel_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ReleaseChannel>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ReleaseChannel_Name.");
    return ClientPayload_UserAgent_ReleaseChannel_Name(enum_t_value);
  }
  static inline bool ReleaseChannel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ReleaseChannel* value) {
    return ClientPayload_UserAgent_ReleaseChannel_Parse(name, value);
  }

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

  enum : int {
    kMccFieldNumber = 3,
    kMncFieldNumber = 4,
    kOsVersionFieldNumber = 5,
    kManufacturerFieldNumber = 6,
    kDeviceFieldNumber = 7,
    kOsBuildNumberFieldNumber = 8,
    kPhoneIdFieldNumber = 9,
    kLocaleLanguageIso6391FieldNumber = 11,
    kLocaleCountryIso31661Alpha2FieldNumber = 12,
    kDeviceBoardFieldNumber = 13,
    kAppVersionFieldNumber = 2,
    kPlatformFieldNumber = 1,
    kReleaseChannelFieldNumber = 10,
  };
  // optional string mcc = 3;
  bool has_mcc() const;
  private:
  bool _internal_has_mcc() const;
  public:
  void clear_mcc();
  const std::string& mcc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mcc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mcc();
  PROTOBUF_NODISCARD std::string* release_mcc();
  void set_allocated_mcc(std::string* mcc);
  private:
  const std::string& _internal_mcc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mcc(const std::string& value);
  std::string* _internal_mutable_mcc();
  public:

  // optional string mnc = 4;
  bool has_mnc() const;
  private:
  bool _internal_has_mnc() const;
  public:
  void clear_mnc();
  const std::string& mnc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mnc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mnc();
  PROTOBUF_NODISCARD std::string* release_mnc();
  void set_allocated_mnc(std::string* mnc);
  private:
  const std::string& _internal_mnc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mnc(const std::string& value);
  std::string* _internal_mutable_mnc();
  public:

  // optional string osVersion = 5;
  bool has_osversion() const;
  private:
  bool _internal_has_osversion() const;
  public:
  void clear_osversion();
  const std::string& osversion() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_osversion(ArgT0&& arg0, ArgT... args);
  std::string* mutable_osversion();
  PROTOBUF_NODISCARD std::string* release_osversion();
  void set_allocated_osversion(std::string* osversion);
  private:
  const std::string& _internal_osversion() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_osversion(const std::string& value);
  std::string* _internal_mutable_osversion();
  public:

  // optional string manufacturer = 6;
  bool has_manufacturer() const;
  private:
  bool _internal_has_manufacturer() const;
  public:
  void clear_manufacturer();
  const std::string& manufacturer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_manufacturer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_manufacturer();
  PROTOBUF_NODISCARD std::string* release_manufacturer();
  void set_allocated_manufacturer(std::string* manufacturer);
  private:
  const std::string& _internal_manufacturer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
  std::string* _internal_mutable_manufacturer();
  public:

  // optional string device = 7;
  bool has_device() const;
  private:
  bool _internal_has_device() const;
  public:
  void clear_device();
  const std::string& device() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_device(ArgT0&& arg0, ArgT... args);
  std::string* mutable_device();
  PROTOBUF_NODISCARD std::string* release_device();
  void set_allocated_device(std::string* device);
  private:
  const std::string& _internal_device() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
  std::string* _internal_mutable_device();
  public:

  // optional string osBuildNumber = 8;
  bool has_osbuildnumber() const;
  private:
  bool _internal_has_osbuildnumber() const;
  public:
  void clear_osbuildnumber();
  const std::string& osbuildnumber() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_osbuildnumber(ArgT0&& arg0, ArgT... args);
  std::string* mutable_osbuildnumber();
  PROTOBUF_NODISCARD std::string* release_osbuildnumber();
  void set_allocated_osbuildnumber(std::string* osbuildnumber);
  private:
  const std::string& _internal_osbuildnumber() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_osbuildnumber(const std::string& value);
  std::string* _internal_mutable_osbuildnumber();
  public:

  // optional string phoneId = 9;
  bool has_phoneid() const;
  private:
  bool _internal_has_phoneid() const;
  public:
  void clear_phoneid();
  const std::string& phoneid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_phoneid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_phoneid();
  PROTOBUF_NODISCARD std::string* release_phoneid();
  void set_allocated_phoneid(std::string* phoneid);
  private:
  const std::string& _internal_phoneid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phoneid(const std::string& value);
  std::string* _internal_mutable_phoneid();
  public:

  // optional string localeLanguageIso6391 = 11;
  bool has_localelanguageiso6391() const;
  private:
  bool _internal_has_localelanguageiso6391() const;
  public:
  void clear_localelanguageiso6391();
  const std::string& localelanguageiso6391() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localelanguageiso6391(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localelanguageiso6391();
  PROTOBUF_NODISCARD std::string* release_localelanguageiso6391();
  void set_allocated_localelanguageiso6391(std::string* localelanguageiso6391);
  private:
  const std::string& _internal_localelanguageiso6391() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localelanguageiso6391(const std::string& value);
  std::string* _internal_mutable_localelanguageiso6391();
  public:

  // optional string localeCountryIso31661Alpha2 = 12;
  bool has_localecountryiso31661alpha2() const;
  private:
  bool _internal_has_localecountryiso31661alpha2() const;
  public:
  void clear_localecountryiso31661alpha2();
  const std::string& localecountryiso31661alpha2() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localecountryiso31661alpha2();
  PROTOBUF_NODISCARD std::string* release_localecountryiso31661alpha2();
  void set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2);
  private:
  const std::string& _internal_localecountryiso31661alpha2() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localecountryiso31661alpha2(const std::string& value);
  std::string* _internal_mutable_localecountryiso31661alpha2();
  public:

  // optional string deviceBoard = 13;
  bool has_deviceboard() const;
  private:
  bool _internal_has_deviceboard() const;
  public:
  void clear_deviceboard();
  const std::string& deviceboard() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_deviceboard(ArgT0&& arg0, ArgT... args);
  std::string* mutable_deviceboard();
  PROTOBUF_NODISCARD std::string* release_deviceboard();
  void set_allocated_deviceboard(std::string* deviceboard);
  private:
  const std::string& _internal_deviceboard() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deviceboard(const std::string& value);
  std::string* _internal_mutable_deviceboard();
  public:

  // optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
  bool has_appversion() const;
  private:
  bool _internal_has_appversion() const;
  public:
  void clear_appversion();
  const ::proto::ClientPayload_UserAgent_AppVersion& appversion() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent_AppVersion* release_appversion();
  ::proto::ClientPayload_UserAgent_AppVersion* mutable_appversion();
  void set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion);
  private:
  const ::proto::ClientPayload_UserAgent_AppVersion& _internal_appversion() const;
  ::proto::ClientPayload_UserAgent_AppVersion* _internal_mutable_appversion();
  public:
  void unsafe_arena_set_allocated_appversion(
      ::proto::ClientPayload_UserAgent_AppVersion* appversion);
  ::proto::ClientPayload_UserAgent_AppVersion* unsafe_arena_release_appversion();

  // optional .proto.ClientPayload.UserAgent.Platform platform = 1;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  ::proto::ClientPayload_UserAgent_Platform platform() const;
  void set_platform(::proto::ClientPayload_UserAgent_Platform value);
  private:
  ::proto::ClientPayload_UserAgent_Platform _internal_platform() const;
  void _internal_set_platform(::proto::ClientPayload_UserAgent_Platform value);
  public:

  // optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
  bool has_releasechannel() const;
  private:
  bool _internal_has_releasechannel() const;
  public:
  void clear_releasechannel();
  ::proto::ClientPayload_UserAgent_ReleaseChannel releasechannel() const;
  void set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value);
  private:
  ::proto::ClientPayload_UserAgent_ReleaseChannel _internal_releasechannel() const;
  void _internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.UserAgent)
 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 mcc_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mnc_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osversion_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr osbuildnumber_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phoneid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localelanguageiso6391_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localecountryiso31661alpha2_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deviceboard_;
    ::proto::ClientPayload_UserAgent_AppVersion* appversion_;
    int platform_;
    int releasechannel_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_WebInfo_WebdPayload final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo.WebdPayload) */ {
 public:
  inline ClientPayload_WebInfo_WebdPayload() : ClientPayload_WebInfo_WebdPayload(nullptr) {}
  ~ClientPayload_WebInfo_WebdPayload() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo_WebdPayload(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_WebInfo_WebdPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_WebInfo_WebdPayload>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_WebInfo_WebdPayload& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_WebInfo_WebdPayload& from) {
    ClientPayload_WebInfo_WebdPayload::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDocumentTypesFieldNumber = 10,
    kFeaturesFieldNumber = 11,
    kUsesParticipantInKeyFieldNumber = 1,
    kSupportsStarredMessagesFieldNumber = 2,
    kSupportsDocumentMessagesFieldNumber = 3,
    kSupportsUrlMessagesFieldNumber = 4,
    kSupportsMediaRetryFieldNumber = 5,
    kSupportsE2EImageFieldNumber = 6,
    kSupportsE2EVideoFieldNumber = 7,
    kSupportsE2EAudioFieldNumber = 8,
    kSupportsE2EDocumentFieldNumber = 9,
  };
  // optional string documentTypes = 10;
  bool has_documenttypes() const;
  private:
  bool _internal_has_documenttypes() const;
  public:
  void clear_documenttypes();
  const std::string& documenttypes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_documenttypes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_documenttypes();
  PROTOBUF_NODISCARD std::string* release_documenttypes();
  void set_allocated_documenttypes(std::string* documenttypes);
  private:
  const std::string& _internal_documenttypes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_documenttypes(const std::string& value);
  std::string* _internal_mutable_documenttypes();
  public:

  // optional bytes features = 11;
  bool has_features() const;
  private:
  bool _internal_has_features() const;
  public:
  void clear_features();
  const std::string& features() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_features(ArgT0&& arg0, ArgT... args);
  std::string* mutable_features();
  PROTOBUF_NODISCARD std::string* release_features();
  void set_allocated_features(std::string* features);
  private:
  const std::string& _internal_features() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_features(const std::string& value);
  std::string* _internal_mutable_features();
  public:

  // optional bool usesParticipantInKey = 1;
  bool has_usesparticipantinkey() const;
  private:
  bool _internal_has_usesparticipantinkey() const;
  public:
  void clear_usesparticipantinkey();
  bool usesparticipantinkey() const;
  void set_usesparticipantinkey(bool value);
  private:
  bool _internal_usesparticipantinkey() const;
  void _internal_set_usesparticipantinkey(bool value);
  public:

  // optional bool supportsStarredMessages = 2;
  bool has_supportsstarredmessages() const;
  private:
  bool _internal_has_supportsstarredmessages() const;
  public:
  void clear_supportsstarredmessages();
  bool supportsstarredmessages() const;
  void set_supportsstarredmessages(bool value);
  private:
  bool _internal_supportsstarredmessages() const;
  void _internal_set_supportsstarredmessages(bool value);
  public:

  // optional bool supportsDocumentMessages = 3;
  bool has_supportsdocumentmessages() const;
  private:
  bool _internal_has_supportsdocumentmessages() const;
  public:
  void clear_supportsdocumentmessages();
  bool supportsdocumentmessages() const;
  void set_supportsdocumentmessages(bool value);
  private:
  bool _internal_supportsdocumentmessages() const;
  void _internal_set_supportsdocumentmessages(bool value);
  public:

  // optional bool supportsUrlMessages = 4;
  bool has_supportsurlmessages() const;
  private:
  bool _internal_has_supportsurlmessages() const;
  public:
  void clear_supportsurlmessages();
  bool supportsurlmessages() const;
  void set_supportsurlmessages(bool value);
  private:
  bool _internal_supportsurlmessages() const;
  void _internal_set_supportsurlmessages(bool value);
  public:

  // optional bool supportsMediaRetry = 5;
  bool has_supportsmediaretry() const;
  private:
  bool _internal_has_supportsmediaretry() const;
  public:
  void clear_supportsmediaretry();
  bool supportsmediaretry() const;
  void set_supportsmediaretry(bool value);
  private:
  bool _internal_supportsmediaretry() const;
  void _internal_set_supportsmediaretry(bool value);
  public:

  // optional bool supportsE2EImage = 6;
  bool has_supportse2eimage() const;
  private:
  bool _internal_has_supportse2eimage() const;
  public:
  void clear_supportse2eimage();
  bool supportse2eimage() const;
  void set_supportse2eimage(bool value);
  private:
  bool _internal_supportse2eimage() const;
  void _internal_set_supportse2eimage(bool value);
  public:

  // optional bool supportsE2EVideo = 7;
  bool has_supportse2evideo() const;
  private:
  bool _internal_has_supportse2evideo() const;
  public:
  void clear_supportse2evideo();
  bool supportse2evideo() const;
  void set_supportse2evideo(bool value);
  private:
  bool _internal_supportse2evideo() const;
  void _internal_set_supportse2evideo(bool value);
  public:

  // optional bool supportsE2EAudio = 8;
  bool has_supportse2eaudio() const;
  private:
  bool _internal_has_supportse2eaudio() const;
  public:
  void clear_supportse2eaudio();
  bool supportse2eaudio() const;
  void set_supportse2eaudio(bool value);
  private:
  bool _internal_supportse2eaudio() const;
  void _internal_set_supportse2eaudio(bool value);
  public:

  // optional bool supportsE2EDocument = 9;
  bool has_supportse2edocument() const;
  private:
  bool _internal_has_supportse2edocument() const;
  public:
  void clear_supportse2edocument();
  bool supportse2edocument() const;
  void set_supportse2edocument(bool value);
  private:
  bool _internal_supportse2edocument() const;
  void _internal_set_supportse2edocument(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo.WebdPayload)
 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 documenttypes_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr features_;
    bool usesparticipantinkey_;
    bool supportsstarredmessages_;
    bool supportsdocumentmessages_;
    bool supportsurlmessages_;
    bool supportsmediaretry_;
    bool supportse2eimage_;
    bool supportse2evideo_;
    bool supportse2eaudio_;
    bool supportse2edocument_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ClientPayload_WebInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ClientPayload.WebInfo) */ {
 public:
  inline ClientPayload_WebInfo() : ClientPayload_WebInfo(nullptr) {}
  ~ClientPayload_WebInfo() override;
  explicit PROTOBUF_CONSTEXPR ClientPayload_WebInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload_WebInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload_WebInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload_WebInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload_WebInfo& from) {
    ClientPayload_WebInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ClientPayload_WebInfo_WebdPayload WebdPayload;

  typedef ClientPayload_WebInfo_WebSubPlatform WebSubPlatform;
  static constexpr WebSubPlatform WEB_BROWSER =
    ClientPayload_WebInfo_WebSubPlatform_WEB_BROWSER;
  static constexpr WebSubPlatform APP_STORE =
    ClientPayload_WebInfo_WebSubPlatform_APP_STORE;
  static constexpr WebSubPlatform WIN_STORE =
    ClientPayload_WebInfo_WebSubPlatform_WIN_STORE;
  static constexpr WebSubPlatform DARWIN =
    ClientPayload_WebInfo_WebSubPlatform_DARWIN;
  static constexpr WebSubPlatform WINDA =
    ClientPayload_WebInfo_WebSubPlatform_WINDA;
  static inline bool WebSubPlatform_IsValid(int value) {
    return ClientPayload_WebInfo_WebSubPlatform_IsValid(value);
  }
  static constexpr WebSubPlatform WebSubPlatform_MIN =
    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MIN;
  static constexpr WebSubPlatform WebSubPlatform_MAX =
    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_MAX;
  static constexpr int WebSubPlatform_ARRAYSIZE =
    ClientPayload_WebInfo_WebSubPlatform_WebSubPlatform_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  WebSubPlatform_descriptor() {
    return ClientPayload_WebInfo_WebSubPlatform_descriptor();
  }
  template<typename T>
  static inline const std::string& WebSubPlatform_Name(T enum_t_value) {
    static_assert(::std::is_same<T, WebSubPlatform>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function WebSubPlatform_Name.");
    return ClientPayload_WebInfo_WebSubPlatform_Name(enum_t_value);
  }
  static inline bool WebSubPlatform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      WebSubPlatform* value) {
    return ClientPayload_WebInfo_WebSubPlatform_Parse(name, value);
  }

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

  enum : int {
    kRefTokenFieldNumber = 1,
    kVersionFieldNumber = 2,
    kWebdPayloadFieldNumber = 3,
    kWebSubPlatformFieldNumber = 4,
  };
  // optional string refToken = 1;
  bool has_reftoken() const;
  private:
  bool _internal_has_reftoken() const;
  public:
  void clear_reftoken();
  const std::string& reftoken() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_reftoken(ArgT0&& arg0, ArgT... args);
  std::string* mutable_reftoken();
  PROTOBUF_NODISCARD std::string* release_reftoken();
  void set_allocated_reftoken(std::string* reftoken);
  private:
  const std::string& _internal_reftoken() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_reftoken(const std::string& value);
  std::string* _internal_mutable_reftoken();
  public:

  // optional string version = 2;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
  bool has_webdpayload() const;
  private:
  bool _internal_has_webdpayload() const;
  public:
  void clear_webdpayload();
  const ::proto::ClientPayload_WebInfo_WebdPayload& webdpayload() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo_WebdPayload* release_webdpayload();
  ::proto::ClientPayload_WebInfo_WebdPayload* mutable_webdpayload();
  void set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload);
  private:
  const ::proto::ClientPayload_WebInfo_WebdPayload& _internal_webdpayload() const;
  ::proto::ClientPayload_WebInfo_WebdPayload* _internal_mutable_webdpayload();
  public:
  void unsafe_arena_set_allocated_webdpayload(
      ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload);
  ::proto::ClientPayload_WebInfo_WebdPayload* unsafe_arena_release_webdpayload();

  // optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
  bool has_websubplatform() const;
  private:
  bool _internal_has_websubplatform() const;
  public:
  void clear_websubplatform();
  ::proto::ClientPayload_WebInfo_WebSubPlatform websubplatform() const;
  void set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value);
  private:
  ::proto::ClientPayload_WebInfo_WebSubPlatform _internal_websubplatform() const;
  void _internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload.WebInfo)
 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 reftoken_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
    ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload_;
    int websubplatform_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ClientPayload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ClientPayload>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientPayload& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ClientPayload& from) {
    ClientPayload::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ClientPayload_DNSSource DNSSource;
  typedef ClientPayload_DevicePairingRegistrationData DevicePairingRegistrationData;
  typedef ClientPayload_UserAgent UserAgent;
  typedef ClientPayload_WebInfo WebInfo;

  typedef ClientPayload_ConnectReason ConnectReason;
  static constexpr ConnectReason PUSH =
    ClientPayload_ConnectReason_PUSH;
  static constexpr ConnectReason USER_ACTIVATED =
    ClientPayload_ConnectReason_USER_ACTIVATED;
  static constexpr ConnectReason SCHEDULED =
    ClientPayload_ConnectReason_SCHEDULED;
  static constexpr ConnectReason ERROR_RECONNECT =
    ClientPayload_ConnectReason_ERROR_RECONNECT;
  static constexpr ConnectReason NETWORK_SWITCH =
    ClientPayload_ConnectReason_NETWORK_SWITCH;
  static constexpr ConnectReason PING_RECONNECT =
    ClientPayload_ConnectReason_PING_RECONNECT;
  static inline bool ConnectReason_IsValid(int value) {
    return ClientPayload_ConnectReason_IsValid(value);
  }
  static constexpr ConnectReason ConnectReason_MIN =
    ClientPayload_ConnectReason_ConnectReason_MIN;
  static constexpr ConnectReason ConnectReason_MAX =
    ClientPayload_ConnectReason_ConnectReason_MAX;
  static constexpr int ConnectReason_ARRAYSIZE =
    ClientPayload_ConnectReason_ConnectReason_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ConnectReason_descriptor() {
    return ClientPayload_ConnectReason_descriptor();
  }
  template<typename T>
  static inline const std::string& ConnectReason_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConnectReason>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConnectReason_Name.");
    return ClientPayload_ConnectReason_Name(enum_t_value);
  }
  static inline bool ConnectReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ConnectReason* value) {
    return ClientPayload_ConnectReason_Parse(name, value);
  }

  typedef ClientPayload_ConnectType ConnectType;
  static constexpr ConnectType CELLULAR_UNKNOWN =
    ClientPayload_ConnectType_CELLULAR_UNKNOWN;
  static constexpr ConnectType WIFI_UNKNOWN =
    ClientPayload_ConnectType_WIFI_UNKNOWN;
  static constexpr ConnectType CELLULAR_EDGE =
    ClientPayload_ConnectType_CELLULAR_EDGE;
  static constexpr ConnectType CELLULAR_IDEN =
    ClientPayload_ConnectType_CELLULAR_IDEN;
  static constexpr ConnectType CELLULAR_UMTS =
    ClientPayload_ConnectType_CELLULAR_UMTS;
  static constexpr ConnectType CELLULAR_EVDO =
    ClientPayload_ConnectType_CELLULAR_EVDO;
  static constexpr ConnectType CELLULAR_GPRS =
    ClientPayload_ConnectType_CELLULAR_GPRS;
  static constexpr ConnectType CELLULAR_HSDPA =
    ClientPayload_ConnectType_CELLULAR_HSDPA;
  static constexpr ConnectType CELLULAR_HSUPA =
    ClientPayload_ConnectType_CELLULAR_HSUPA;
  static constexpr ConnectType CELLULAR_HSPA =
    ClientPayload_ConnectType_CELLULAR_HSPA;
  static constexpr ConnectType CELLULAR_CDMA =
    ClientPayload_ConnectType_CELLULAR_CDMA;
  static constexpr ConnectType CELLULAR_1XRTT =
    ClientPayload_ConnectType_CELLULAR_1XRTT;
  static constexpr ConnectType CELLULAR_EHRPD =
    ClientPayload_ConnectType_CELLULAR_EHRPD;
  static constexpr ConnectType CELLULAR_LTE =
    ClientPayload_ConnectType_CELLULAR_LTE;
  static constexpr ConnectType CELLULAR_HSPAP =
    ClientPayload_ConnectType_CELLULAR_HSPAP;
  static inline bool ConnectType_IsValid(int value) {
    return ClientPayload_ConnectType_IsValid(value);
  }
  static constexpr ConnectType ConnectType_MIN =
    ClientPayload_ConnectType_ConnectType_MIN;
  static constexpr ConnectType ConnectType_MAX =
    ClientPayload_ConnectType_ConnectType_MAX;
  static constexpr int ConnectType_ARRAYSIZE =
    ClientPayload_ConnectType_ConnectType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ConnectType_descriptor() {
    return ClientPayload_ConnectType_descriptor();
  }
  template<typename T>
  static inline const std::string& ConnectType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConnectType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConnectType_Name.");
    return ClientPayload_ConnectType_Name(enum_t_value);
  }
  static inline bool ConnectType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ConnectType* value) {
    return ClientPayload_ConnectType_Parse(name, value);
  }

  typedef ClientPayload_IOSAppExtension IOSAppExtension;
  static constexpr IOSAppExtension SHARE_EXTENSION =
    ClientPayload_IOSAppExtension_SHARE_EXTENSION;
  static constexpr IOSAppExtension SERVICE_EXTENSION =
    ClientPayload_IOSAppExtension_SERVICE_EXTENSION;
  static constexpr IOSAppExtension INTENTS_EXTENSION =
    ClientPayload_IOSAppExtension_INTENTS_EXTENSION;
  static inline bool IOSAppExtension_IsValid(int value) {
    return ClientPayload_IOSAppExtension_IsValid(value);
  }
  static constexpr IOSAppExtension IOSAppExtension_MIN =
    ClientPayload_IOSAppExtension_IOSAppExtension_MIN;
  static constexpr IOSAppExtension IOSAppExtension_MAX =
    ClientPayload_IOSAppExtension_IOSAppExtension_MAX;
  static constexpr int IOSAppExtension_ARRAYSIZE =
    ClientPayload_IOSAppExtension_IOSAppExtension_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  IOSAppExtension_descriptor() {
    return ClientPayload_IOSAppExtension_descriptor();
  }
  template<typename T>
  static inline const std::string& IOSAppExtension_Name(T enum_t_value) {
    static_assert(::std::is_same<T, IOSAppExtension>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function IOSAppExtension_Name.");
    return ClientPayload_IOSAppExtension_Name(enum_t_value);
  }
  static inline bool IOSAppExtension_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      IOSAppExtension* value) {
    return ClientPayload_IOSAppExtension_Parse(name, value);
  }

  typedef ClientPayload_Product Product;
  static constexpr Product WHATSAPP =
    ClientPayload_Product_WHATSAPP;
  static constexpr Product MESSENGER =
    ClientPayload_Product_MESSENGER;
  static inline bool Product_IsValid(int value) {
    return ClientPayload_Product_IsValid(value);
  }
  static constexpr Product Product_MIN =
    ClientPayload_Product_Product_MIN;
  static constexpr Product Product_MAX =
    ClientPayload_Product_Product_MAX;
  static constexpr int Product_ARRAYSIZE =
    ClientPayload_Product_Product_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Product_descriptor() {
    return ClientPayload_Product_descriptor();
  }
  template<typename T>
  static inline const std::string& Product_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Product>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Product_Name.");
    return ClientPayload_Product_Name(enum_t_value);
  }
  static inline bool Product_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Product* value) {
    return ClientPayload_Product_Parse(name, value);
  }

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

  enum : int {
    kShardsFieldNumber = 14,
    kPushNameFieldNumber = 7,
    kFbCatFieldNumber = 21,
    kFbUserAgentFieldNumber = 22,
    kFbDeviceIdFieldNumber = 32,
    kPaddingBytesFieldNumber = 34,
    kUserAgentFieldNumber = 5,
    kWebInfoFieldNumber = 6,
    kDnsSourceFieldNumber = 15,
    kDevicePairingDataFieldNumber = 19,
    kUsernameFieldNumber = 1,
    kSessionIdFieldNumber = 9,
    kConnectTypeFieldNumber = 12,
    kConnectReasonFieldNumber = 13,
    kConnectAttemptCountFieldNumber = 16,
    kPassiveFieldNumber = 3,
    kShortConnectFieldNumber = 10,
    kOcFieldNumber = 23,
    kPullFieldNumber = 33,
    kDeviceFieldNumber = 18,
    kProductFieldNumber = 20,
    kLcFieldNumber = 24,
    kFbAppIdFieldNumber = 31,
    kIosAppExtensionFieldNumber = 30,
  };
  // repeated int32 shards = 14;
  int shards_size() const;
  private:
  int _internal_shards_size() const;
  public:
  void clear_shards();
  private:
  int32_t _internal_shards(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_shards() const;
  void _internal_add_shards(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_shards();
  public:
  int32_t shards(int index) const;
  void set_shards(int index, int32_t value);
  void add_shards(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      shards() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_shards();

  // optional string pushName = 7;
  bool has_pushname() const;
  private:
  bool _internal_has_pushname() const;
  public:
  void clear_pushname();
  const std::string& pushname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pushname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pushname();
  PROTOBUF_NODISCARD std::string* release_pushname();
  void set_allocated_pushname(std::string* pushname);
  private:
  const std::string& _internal_pushname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
  std::string* _internal_mutable_pushname();
  public:

  // optional bytes fbCat = 21;
  bool has_fbcat() const;
  private:
  bool _internal_has_fbcat() const;
  public:
  void clear_fbcat();
  const std::string& fbcat() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fbcat(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fbcat();
  PROTOBUF_NODISCARD std::string* release_fbcat();
  void set_allocated_fbcat(std::string* fbcat);
  private:
  const std::string& _internal_fbcat() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbcat(const std::string& value);
  std::string* _internal_mutable_fbcat();
  public:

  // optional bytes fbUserAgent = 22;
  bool has_fbuseragent() const;
  private:
  bool _internal_has_fbuseragent() const;
  public:
  void clear_fbuseragent();
  const std::string& fbuseragent() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fbuseragent(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fbuseragent();
  PROTOBUF_NODISCARD std::string* release_fbuseragent();
  void set_allocated_fbuseragent(std::string* fbuseragent);
  private:
  const std::string& _internal_fbuseragent() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbuseragent(const std::string& value);
  std::string* _internal_mutable_fbuseragent();
  public:

  // optional bytes fbDeviceId = 32;
  bool has_fbdeviceid() const;
  private:
  bool _internal_has_fbdeviceid() const;
  public:
  void clear_fbdeviceid();
  const std::string& fbdeviceid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fbdeviceid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fbdeviceid();
  PROTOBUF_NODISCARD std::string* release_fbdeviceid();
  void set_allocated_fbdeviceid(std::string* fbdeviceid);
  private:
  const std::string& _internal_fbdeviceid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fbdeviceid(const std::string& value);
  std::string* _internal_mutable_fbdeviceid();
  public:

  // optional bytes paddingBytes = 34;
  bool has_paddingbytes() const;
  private:
  bool _internal_has_paddingbytes() const;
  public:
  void clear_paddingbytes();
  const std::string& paddingbytes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_paddingbytes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_paddingbytes();
  PROTOBUF_NODISCARD std::string* release_paddingbytes();
  void set_allocated_paddingbytes(std::string* paddingbytes);
  private:
  const std::string& _internal_paddingbytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value);
  std::string* _internal_mutable_paddingbytes();
  public:

  // optional .proto.ClientPayload.UserAgent userAgent = 5;
  bool has_useragent() const;
  private:
  bool _internal_has_useragent() const;
  public:
  void clear_useragent();
  const ::proto::ClientPayload_UserAgent& useragent() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_UserAgent* release_useragent();
  ::proto::ClientPayload_UserAgent* mutable_useragent();
  void set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent);
  private:
  const ::proto::ClientPayload_UserAgent& _internal_useragent() const;
  ::proto::ClientPayload_UserAgent* _internal_mutable_useragent();
  public:
  void unsafe_arena_set_allocated_useragent(
      ::proto::ClientPayload_UserAgent* useragent);
  ::proto::ClientPayload_UserAgent* unsafe_arena_release_useragent();

  // optional .proto.ClientPayload.WebInfo webInfo = 6;
  bool has_webinfo() const;
  private:
  bool _internal_has_webinfo() const;
  public:
  void clear_webinfo();
  const ::proto::ClientPayload_WebInfo& webinfo() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_WebInfo* release_webinfo();
  ::proto::ClientPayload_WebInfo* mutable_webinfo();
  void set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo);
  private:
  const ::proto::ClientPayload_WebInfo& _internal_webinfo() const;
  ::proto::ClientPayload_WebInfo* _internal_mutable_webinfo();
  public:
  void unsafe_arena_set_allocated_webinfo(
      ::proto::ClientPayload_WebInfo* webinfo);
  ::proto::ClientPayload_WebInfo* unsafe_arena_release_webinfo();

  // optional .proto.ClientPayload.DNSSource dnsSource = 15;
  bool has_dnssource() const;
  private:
  bool _internal_has_dnssource() const;
  public:
  void clear_dnssource();
  const ::proto::ClientPayload_DNSSource& dnssource() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_DNSSource* release_dnssource();
  ::proto::ClientPayload_DNSSource* mutable_dnssource();
  void set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource);
  private:
  const ::proto::ClientPayload_DNSSource& _internal_dnssource() const;
  ::proto::ClientPayload_DNSSource* _internal_mutable_dnssource();
  public:
  void unsafe_arena_set_allocated_dnssource(
      ::proto::ClientPayload_DNSSource* dnssource);
  ::proto::ClientPayload_DNSSource* unsafe_arena_release_dnssource();

  // optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
  bool has_devicepairingdata() const;
  private:
  bool _internal_has_devicepairingdata() const;
  public:
  void clear_devicepairingdata();
  const ::proto::ClientPayload_DevicePairingRegistrationData& devicepairingdata() const;
  PROTOBUF_NODISCARD ::proto::ClientPayload_DevicePairingRegistrationData* release_devicepairingdata();
  ::proto::ClientPayload_DevicePairingRegistrationData* mutable_devicepairingdata();
  void set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata);
  private:
  const ::proto::ClientPayload_DevicePairingRegistrationData& _internal_devicepairingdata() const;
  ::proto::ClientPayload_DevicePairingRegistrationData* _internal_mutable_devicepairingdata();
  public:
  void unsafe_arena_set_allocated_devicepairingdata(
      ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata);
  ::proto::ClientPayload_DevicePairingRegistrationData* unsafe_arena_release_devicepairingdata();

  // optional uint64 username = 1;
  bool has_username() const;
  private:
  bool _internal_has_username() const;
  public:
  void clear_username();
  uint64_t username() const;
  void set_username(uint64_t value);
  private:
  uint64_t _internal_username() const;
  void _internal_set_username(uint64_t value);
  public:

  // optional sfixed32 sessionId = 9;
  bool has_sessionid() const;
  private:
  bool _internal_has_sessionid() const;
  public:
  void clear_sessionid();
  int32_t sessionid() const;
  void set_sessionid(int32_t value);
  private:
  int32_t _internal_sessionid() const;
  void _internal_set_sessionid(int32_t value);
  public:

  // optional .proto.ClientPayload.ConnectType connectType = 12;
  bool has_connecttype() const;
  private:
  bool _internal_has_connecttype() const;
  public:
  void clear_connecttype();
  ::proto::ClientPayload_ConnectType connecttype() const;
  void set_connecttype(::proto::ClientPayload_ConnectType value);
  private:
  ::proto::ClientPayload_ConnectType _internal_connecttype() const;
  void _internal_set_connecttype(::proto::ClientPayload_ConnectType value);
  public:

  // optional .proto.ClientPayload.ConnectReason connectReason = 13;
  bool has_connectreason() const;
  private:
  bool _internal_has_connectreason() const;
  public:
  void clear_connectreason();
  ::proto::ClientPayload_ConnectReason connectreason() const;
  void set_connectreason(::proto::ClientPayload_ConnectReason value);
  private:
  ::proto::ClientPayload_ConnectReason _internal_connectreason() const;
  void _internal_set_connectreason(::proto::ClientPayload_ConnectReason value);
  public:

  // optional uint32 connectAttemptCount = 16;
  bool has_connectattemptcount() const;
  private:
  bool _internal_has_connectattemptcount() const;
  public:
  void clear_connectattemptcount();
  uint32_t connectattemptcount() const;
  void set_connectattemptcount(uint32_t value);
  private:
  uint32_t _internal_connectattemptcount() const;
  void _internal_set_connectattemptcount(uint32_t value);
  public:

  // optional bool passive = 3;
  bool has_passive() const;
  private:
  bool _internal_has_passive() const;
  public:
  void clear_passive();
  bool passive() const;
  void set_passive(bool value);
  private:
  bool _internal_passive() const;
  void _internal_set_passive(bool value);
  public:

  // optional bool shortConnect = 10;
  bool has_shortconnect() const;
  private:
  bool _internal_has_shortconnect() const;
  public:
  void clear_shortconnect();
  bool shortconnect() const;
  void set_shortconnect(bool value);
  private:
  bool _internal_shortconnect() const;
  void _internal_set_shortconnect(bool value);
  public:

  // optional bool oc = 23;
  bool has_oc() const;
  private:
  bool _internal_has_oc() const;
  public:
  void clear_oc();
  bool oc() const;
  void set_oc(bool value);
  private:
  bool _internal_oc() const;
  void _internal_set_oc(bool value);
  public:

  // optional bool pull = 33;
  bool has_pull() const;
  private:
  bool _internal_has_pull() const;
  public:
  void clear_pull();
  bool pull() const;
  void set_pull(bool value);
  private:
  bool _internal_pull() const;
  void _internal_set_pull(bool value);
  public:

  // optional uint32 device = 18;
  bool has_device() const;
  private:
  bool _internal_has_device() const;
  public:
  void clear_device();
  uint32_t device() const;
  void set_device(uint32_t value);
  private:
  uint32_t _internal_device() const;
  void _internal_set_device(uint32_t value);
  public:

  // optional .proto.ClientPayload.Product product = 20;
  bool has_product() const;
  private:
  bool _internal_has_product() const;
  public:
  void clear_product();
  ::proto::ClientPayload_Product product() const;
  void set_product(::proto::ClientPayload_Product value);
  private:
  ::proto::ClientPayload_Product _internal_product() const;
  void _internal_set_product(::proto::ClientPayload_Product value);
  public:

  // optional int32 lc = 24;
  bool has_lc() const;
  private:
  bool _internal_has_lc() const;
  public:
  void clear_lc();
  int32_t lc() const;
  void set_lc(int32_t value);
  private:
  int32_t _internal_lc() const;
  void _internal_set_lc(int32_t value);
  public:

  // optional uint64 fbAppId = 31;
  bool has_fbappid() const;
  private:
  bool _internal_has_fbappid() const;
  public:
  void clear_fbappid();
  uint64_t fbappid() const;
  void set_fbappid(uint64_t value);
  private:
  uint64_t _internal_fbappid() const;
  void _internal_set_fbappid(uint64_t value);
  public:

  // optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
  bool has_iosappextension() const;
  private:
  bool _internal_has_iosappextension() const;
  public:
  void clear_iosappextension();
  ::proto::ClientPayload_IOSAppExtension iosappextension() const;
  void set_iosappextension(::proto::ClientPayload_IOSAppExtension value);
  private:
  ::proto::ClientPayload_IOSAppExtension _internal_iosappextension() const;
  void _internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ClientPayload)
 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< int32_t > shards_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbcat_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbuseragent_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fbdeviceid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_;
    ::proto::ClientPayload_UserAgent* useragent_;
    ::proto::ClientPayload_WebInfo* webinfo_;
    ::proto::ClientPayload_DNSSource* dnssource_;
    ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata_;
    uint64_t username_;
    int32_t sessionid_;
    int connecttype_;
    int connectreason_;
    uint32_t connectattemptcount_;
    bool passive_;
    bool shortconnect_;
    bool oc_;
    bool pull_;
    uint32_t device_;
    int product_;
    int32_t lc_;
    uint64_t fbappid_;
    int iosappextension_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ContextInfo_AdReplyInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.AdReplyInfo) */ {
 public:
  inline ContextInfo_AdReplyInfo() : ContextInfo_AdReplyInfo(nullptr) {}
  ~ContextInfo_AdReplyInfo() override;
  explicit PROTOBUF_CONSTEXPR ContextInfo_AdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ContextInfo_AdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ContextInfo_AdReplyInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ContextInfo_AdReplyInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ContextInfo_AdReplyInfo& from) {
    ContextInfo_AdReplyInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ContextInfo_AdReplyInfo_MediaType MediaType;
  static constexpr MediaType NONE =
    ContextInfo_AdReplyInfo_MediaType_NONE;
  static constexpr MediaType IMAGE =
    ContextInfo_AdReplyInfo_MediaType_IMAGE;
  static constexpr MediaType VIDEO =
    ContextInfo_AdReplyInfo_MediaType_VIDEO;
  static inline bool MediaType_IsValid(int value) {
    return ContextInfo_AdReplyInfo_MediaType_IsValid(value);
  }
  static constexpr MediaType MediaType_MIN =
    ContextInfo_AdReplyInfo_MediaType_MediaType_MIN;
  static constexpr MediaType MediaType_MAX =
    ContextInfo_AdReplyInfo_MediaType_MediaType_MAX;
  static constexpr int MediaType_ARRAYSIZE =
    ContextInfo_AdReplyInfo_MediaType_MediaType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MediaType_descriptor() {
    return ContextInfo_AdReplyInfo_MediaType_descriptor();
  }
  template<typename T>
  static inline const std::string& MediaType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MediaType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MediaType_Name.");
    return ContextInfo_AdReplyInfo_MediaType_Name(enum_t_value);
  }
  static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MediaType* value) {
    return ContextInfo_AdReplyInfo_MediaType_Parse(name, value);
  }

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

  enum : int {
    kAdvertiserNameFieldNumber = 1,
    kJpegThumbnailFieldNumber = 16,
    kCaptionFieldNumber = 17,
    kMediaTypeFieldNumber = 2,
  };
  // optional string advertiserName = 1;
  bool has_advertisername() const;
  private:
  bool _internal_has_advertisername() const;
  public:
  void clear_advertisername();
  const std::string& advertisername() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_advertisername(ArgT0&& arg0, ArgT... args);
  std::string* mutable_advertisername();
  PROTOBUF_NODISCARD std::string* release_advertisername();
  void set_allocated_advertisername(std::string* advertisername);
  private:
  const std::string& _internal_advertisername() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_advertisername(const std::string& value);
  std::string* _internal_mutable_advertisername();
  public:

  // optional bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional string caption = 17;
  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 .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
  bool has_mediatype() const;
  private:
  bool _internal_has_mediatype() const;
  public:
  void clear_mediatype();
  ::proto::ContextInfo_AdReplyInfo_MediaType mediatype() const;
  void set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value);
  private:
  ::proto::ContextInfo_AdReplyInfo_MediaType _internal_mediatype() const;
  void _internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ContextInfo.AdReplyInfo)
 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 advertisername_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    int mediatype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ContextInfo_ExternalAdReplyInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ContextInfo.ExternalAdReplyInfo) */ {
 public:
  inline ContextInfo_ExternalAdReplyInfo() : ContextInfo_ExternalAdReplyInfo(nullptr) {}
  ~ContextInfo_ExternalAdReplyInfo() override;
  explicit PROTOBUF_CONSTEXPR ContextInfo_ExternalAdReplyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ContextInfo_ExternalAdReplyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ContextInfo_ExternalAdReplyInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ContextInfo_ExternalAdReplyInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ContextInfo_ExternalAdReplyInfo& from) {
    ContextInfo_ExternalAdReplyInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ContextInfo_ExternalAdReplyInfo_MediaType MediaType;
  static constexpr MediaType NONE =
    ContextInfo_ExternalAdReplyInfo_MediaType_NONE;
  static constexpr MediaType IMAGE =
    ContextInfo_ExternalAdReplyInfo_MediaType_IMAGE;
  static constexpr MediaType VIDEO =
    ContextInfo_ExternalAdReplyInfo_MediaType_VIDEO;
  static inline bool MediaType_IsValid(int value) {
    return ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value);
  }
  static constexpr MediaType MediaType_MIN =
    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MIN;
  static constexpr MediaType MediaType_MAX =
    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_MAX;
  static constexpr int MediaType_ARRAYSIZE =
    ContextInfo_ExternalAdReplyInfo_MediaType_MediaType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MediaType_descriptor() {
    return ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
  }
  template<typename T>
  static inline const std::string& MediaType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MediaType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MediaType_Name.");
    return ContextInfo_ExternalAdReplyInfo_MediaType_Name(enum_t_value);
  }
  static inline bool MediaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MediaType* value) {
    return ContextInfo_ExternalAdReplyInfo_MediaType_Parse(name, value);
  }

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

  enum : int {
    kTitleFieldNumber = 1,
    kBodyFieldNumber = 2,
    kThumbnailUrlFieldNumber = 4,
    kMediaUrlFieldNumber = 5,
    kThumbnailFieldNumber = 6,
    kSourceTypeFieldNumber = 7,
    kSourceIdFieldNumber = 8,
    kSourceUrlFieldNumber = 9,
    kMediaTypeFieldNumber = 3,
    kContainsAutoReplyFieldNumber = 10,
    kRenderLargerThumbnailFieldNumber = 11,
    kShowAdAttributionFieldNumber = 12,
  };
  // optional string title = 1;
  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 string body = 2;
  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 string thumbnailUrl = 4;
  bool has_thumbnailurl() const;
  private:
  bool _internal_has_thumbnailurl() const;
  public:
  void clear_thumbnailurl();
  const std::string& thumbnailurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailurl();
  PROTOBUF_NODISCARD std::string* release_thumbnailurl();
  void set_allocated_thumbnailurl(std::string* thumbnailurl);
  private:
  const std::string& _internal_thumbnailurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailurl(const std::string& value);
  std::string* _internal_mutable_thumbnailurl();
  public:

  // optional string mediaUrl = 5;
  bool has_mediaurl() const;
  private:
  bool _internal_has_mediaurl() const;
  public:
  void clear_mediaurl();
  const std::string& mediaurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediaurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediaurl();
  PROTOBUF_NODISCARD std::string* release_mediaurl();
  void set_allocated_mediaurl(std::string* mediaurl);
  private:
  const std::string& _internal_mediaurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaurl(const std::string& value);
  std::string* _internal_mutable_mediaurl();
  public:

  // optional bytes thumbnail = 6;
  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 string sourceType = 7;
  bool has_sourcetype() const;
  private:
  bool _internal_has_sourcetype() const;
  public:
  void clear_sourcetype();
  const std::string& sourcetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourcetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourcetype();
  PROTOBUF_NODISCARD std::string* release_sourcetype();
  void set_allocated_sourcetype(std::string* sourcetype);
  private:
  const std::string& _internal_sourcetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourcetype(const std::string& value);
  std::string* _internal_mutable_sourcetype();
  public:

  // optional string sourceId = 8;
  bool has_sourceid() const;
  private:
  bool _internal_has_sourceid() const;
  public:
  void clear_sourceid();
  const std::string& sourceid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceid();
  PROTOBUF_NODISCARD std::string* release_sourceid();
  void set_allocated_sourceid(std::string* sourceid);
  private:
  const std::string& _internal_sourceid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceid(const std::string& value);
  std::string* _internal_mutable_sourceid();
  public:

  // optional string sourceUrl = 9;
  bool has_sourceurl() const;
  private:
  bool _internal_has_sourceurl() const;
  public:
  void clear_sourceurl();
  const std::string& sourceurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sourceurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sourceurl();
  PROTOBUF_NODISCARD std::string* release_sourceurl();
  void set_allocated_sourceurl(std::string* sourceurl);
  private:
  const std::string& _internal_sourceurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sourceurl(const std::string& value);
  std::string* _internal_mutable_sourceurl();
  public:

  // optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
  bool has_mediatype() const;
  private:
  bool _internal_has_mediatype() const;
  public:
  void clear_mediatype();
  ::proto::ContextInfo_ExternalAdReplyInfo_MediaType mediatype() const;
  void set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value);
  private:
  ::proto::ContextInfo_ExternalAdReplyInfo_MediaType _internal_mediatype() const;
  void _internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value);
  public:

  // optional bool containsAutoReply = 10;
  bool has_containsautoreply() const;
  private:
  bool _internal_has_containsautoreply() const;
  public:
  void clear_containsautoreply();
  bool containsautoreply() const;
  void set_containsautoreply(bool value);
  private:
  bool _internal_containsautoreply() const;
  void _internal_set_containsautoreply(bool value);
  public:

  // optional bool renderLargerThumbnail = 11;
  bool has_renderlargerthumbnail() const;
  private:
  bool _internal_has_renderlargerthumbnail() const;
  public:
  void clear_renderlargerthumbnail();
  bool renderlargerthumbnail() const;
  void set_renderlargerthumbnail(bool value);
  private:
  bool _internal_renderlargerthumbnail() const;
  void _internal_set_renderlargerthumbnail(bool value);
  public:

  // optional bool showAdAttribution = 12;
  bool has_showadattribution() const;
  private:
  bool _internal_has_showadattribution() const;
  public:
  void clear_showadattribution();
  bool showadattribution() const;
  void set_showadattribution(bool value);
  private:
  bool _internal_showadattribution() const;
  void _internal_set_showadattribution(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ContextInfo.ExternalAdReplyInfo)
 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 title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailurl_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaurl_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourcetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sourceurl_;
    int mediatype_;
    bool containsautoreply_;
    bool renderlargerthumbnail_;
    bool showadattribution_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ContextInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ContextInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ContextInfo& from) {
    ContextInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef ContextInfo_AdReplyInfo AdReplyInfo;
  typedef ContextInfo_ExternalAdReplyInfo ExternalAdReplyInfo;

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

  enum : int {
    kMentionedJidFieldNumber = 15,
    kStanzaIdFieldNumber = 1,
    kParticipantFieldNumber = 2,
    kRemoteJidFieldNumber = 4,
    kConversionSourceFieldNumber = 18,
    kConversionDataFieldNumber = 19,
    kEphemeralSharedSecretFieldNumber = 27,
    kEntryPointConversionSourceFieldNumber = 29,
    kEntryPointConversionAppFieldNumber = 30,
    kGroupSubjectFieldNumber = 34,
    kParentGroupJidFieldNumber = 35,
    kQuotedMessageFieldNumber = 3,
    kQuotedAdFieldNumber = 23,
    kPlaceholderKeyFieldNumber = 24,
    kExternalAdReplyFieldNumber = 28,
    kDisappearingModeFieldNumber = 32,
    kActionLinkFieldNumber = 33,
    kConversionDelaySecondsFieldNumber = 20,
    kForwardingScoreFieldNumber = 21,
    kIsForwardedFieldNumber = 22,
    kExpirationFieldNumber = 25,
    kEphemeralSettingTimestampFieldNumber = 26,
    kEntryPointConversionDelaySecondsFieldNumber = 31,
  };
  // repeated string mentionedJid = 15;
  int mentionedjid_size() const;
  private:
  int _internal_mentionedjid_size() const;
  public:
  void clear_mentionedjid();
  const std::string& mentionedjid(int index) const;
  std::string* mutable_mentionedjid(int index);
  void set_mentionedjid(int index, const std::string& value);
  void set_mentionedjid(int index, std::string&& value);
  void set_mentionedjid(int index, const char* value);
  void set_mentionedjid(int index, const char* value, size_t size);
  std::string* add_mentionedjid();
  void add_mentionedjid(const std::string& value);
  void add_mentionedjid(std::string&& value);
  void add_mentionedjid(const char* value);
  void add_mentionedjid(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& mentionedjid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_mentionedjid();
  private:
  const std::string& _internal_mentionedjid(int index) const;
  std::string* _internal_add_mentionedjid();
  public:

  // optional string stanzaId = 1;
  bool has_stanzaid() const;
  private:
  bool _internal_has_stanzaid() const;
  public:
  void clear_stanzaid();
  const std::string& stanzaid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stanzaid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stanzaid();
  PROTOBUF_NODISCARD std::string* release_stanzaid();
  void set_allocated_stanzaid(std::string* stanzaid);
  private:
  const std::string& _internal_stanzaid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
  std::string* _internal_mutable_stanzaid();
  public:

  // optional string participant = 2;
  bool has_participant() const;
  private:
  bool _internal_has_participant() const;
  public:
  void clear_participant();
  const std::string& participant() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_participant(ArgT0&& arg0, ArgT... args);
  std::string* mutable_participant();
  PROTOBUF_NODISCARD std::string* release_participant();
  void set_allocated_participant(std::string* participant);
  private:
  const std::string& _internal_participant() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
  std::string* _internal_mutable_participant();
  public:

  // optional string remoteJid = 4;
  bool has_remotejid() const;
  private:
  bool _internal_has_remotejid() const;
  public:
  void clear_remotejid();
  const std::string& remotejid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remotejid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remotejid();
  PROTOBUF_NODISCARD std::string* release_remotejid();
  void set_allocated_remotejid(std::string* remotejid);
  private:
  const std::string& _internal_remotejid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value);
  std::string* _internal_mutable_remotejid();
  public:

  // optional string conversionSource = 18;
  bool has_conversionsource() const;
  private:
  bool _internal_has_conversionsource() const;
  public:
  void clear_conversionsource();
  const std::string& conversionsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_conversionsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_conversionsource();
  PROTOBUF_NODISCARD std::string* release_conversionsource();
  void set_allocated_conversionsource(std::string* conversionsource);
  private:
  const std::string& _internal_conversionsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value);
  std::string* _internal_mutable_conversionsource();
  public:

  // optional bytes conversionData = 19;
  bool has_conversiondata() const;
  private:
  bool _internal_has_conversiondata() const;
  public:
  void clear_conversiondata();
  const std::string& conversiondata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_conversiondata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_conversiondata();
  PROTOBUF_NODISCARD std::string* release_conversiondata();
  void set_allocated_conversiondata(std::string* conversiondata);
  private:
  const std::string& _internal_conversiondata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value);
  std::string* _internal_mutable_conversiondata();
  public:

  // optional bytes ephemeralSharedSecret = 27;
  bool has_ephemeralsharedsecret() const;
  private:
  bool _internal_has_ephemeralsharedsecret() const;
  public:
  void clear_ephemeralsharedsecret();
  const std::string& ephemeralsharedsecret() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ephemeralsharedsecret();
  PROTOBUF_NODISCARD std::string* release_ephemeralsharedsecret();
  void set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret);
  private:
  const std::string& _internal_ephemeralsharedsecret() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeralsharedsecret(const std::string& value);
  std::string* _internal_mutable_ephemeralsharedsecret();
  public:

  // optional string entryPointConversionSource = 29;
  bool has_entrypointconversionsource() const;
  private:
  bool _internal_has_entrypointconversionsource() const;
  public:
  void clear_entrypointconversionsource();
  const std::string& entrypointconversionsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entrypointconversionsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entrypointconversionsource();
  PROTOBUF_NODISCARD std::string* release_entrypointconversionsource();
  void set_allocated_entrypointconversionsource(std::string* entrypointconversionsource);
  private:
  const std::string& _internal_entrypointconversionsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionsource(const std::string& value);
  std::string* _internal_mutable_entrypointconversionsource();
  public:

  // optional string entryPointConversionApp = 30;
  bool has_entrypointconversionapp() const;
  private:
  bool _internal_has_entrypointconversionapp() const;
  public:
  void clear_entrypointconversionapp();
  const std::string& entrypointconversionapp() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_entrypointconversionapp(ArgT0&& arg0, ArgT... args);
  std::string* mutable_entrypointconversionapp();
  PROTOBUF_NODISCARD std::string* release_entrypointconversionapp();
  void set_allocated_entrypointconversionapp(std::string* entrypointconversionapp);
  private:
  const std::string& _internal_entrypointconversionapp() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entrypointconversionapp(const std::string& value);
  std::string* _internal_mutable_entrypointconversionapp();
  public:

  // optional string groupSubject = 34;
  bool has_groupsubject() const;
  private:
  bool _internal_has_groupsubject() const;
  public:
  void clear_groupsubject();
  const std::string& groupsubject() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupsubject(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupsubject();
  PROTOBUF_NODISCARD std::string* release_groupsubject();
  void set_allocated_groupsubject(std::string* groupsubject);
  private:
  const std::string& _internal_groupsubject() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupsubject(const std::string& value);
  std::string* _internal_mutable_groupsubject();
  public:

  // optional string parentGroupJid = 35;
  bool has_parentgroupjid() const;
  private:
  bool _internal_has_parentgroupjid() const;
  public:
  void clear_parentgroupjid();
  const std::string& parentgroupjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_parentgroupjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_parentgroupjid();
  PROTOBUF_NODISCARD std::string* release_parentgroupjid();
  void set_allocated_parentgroupjid(std::string* parentgroupjid);
  private:
  const std::string& _internal_parentgroupjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupjid(const std::string& value);
  std::string* _internal_mutable_parentgroupjid();
  public:

  // optional .proto.Message quotedMessage = 3;
  bool has_quotedmessage() const;
  private:
  bool _internal_has_quotedmessage() const;
  public:
  void clear_quotedmessage();
  const ::proto::Message& quotedmessage() const;
  PROTOBUF_NODISCARD ::proto::Message* release_quotedmessage();
  ::proto::Message* mutable_quotedmessage();
  void set_allocated_quotedmessage(::proto::Message* quotedmessage);
  private:
  const ::proto::Message& _internal_quotedmessage() const;
  ::proto::Message* _internal_mutable_quotedmessage();
  public:
  void unsafe_arena_set_allocated_quotedmessage(
      ::proto::Message* quotedmessage);
  ::proto::Message* unsafe_arena_release_quotedmessage();

  // optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
  bool has_quotedad() const;
  private:
  bool _internal_has_quotedad() const;
  public:
  void clear_quotedad();
  const ::proto::ContextInfo_AdReplyInfo& quotedad() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo_AdReplyInfo* release_quotedad();
  ::proto::ContextInfo_AdReplyInfo* mutable_quotedad();
  void set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad);
  private:
  const ::proto::ContextInfo_AdReplyInfo& _internal_quotedad() const;
  ::proto::ContextInfo_AdReplyInfo* _internal_mutable_quotedad();
  public:
  void unsafe_arena_set_allocated_quotedad(
      ::proto::ContextInfo_AdReplyInfo* quotedad);
  ::proto::ContextInfo_AdReplyInfo* unsafe_arena_release_quotedad();

  // optional .proto.MessageKey placeholderKey = 24;
  bool has_placeholderkey() const;
  private:
  bool _internal_has_placeholderkey() const;
  public:
  void clear_placeholderkey();
  const ::proto::MessageKey& placeholderkey() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_placeholderkey();
  ::proto::MessageKey* mutable_placeholderkey();
  void set_allocated_placeholderkey(::proto::MessageKey* placeholderkey);
  private:
  const ::proto::MessageKey& _internal_placeholderkey() const;
  ::proto::MessageKey* _internal_mutable_placeholderkey();
  public:
  void unsafe_arena_set_allocated_placeholderkey(
      ::proto::MessageKey* placeholderkey);
  ::proto::MessageKey* unsafe_arena_release_placeholderkey();

  // optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
  bool has_externaladreply() const;
  private:
  bool _internal_has_externaladreply() const;
  public:
  void clear_externaladreply();
  const ::proto::ContextInfo_ExternalAdReplyInfo& externaladreply() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo_ExternalAdReplyInfo* release_externaladreply();
  ::proto::ContextInfo_ExternalAdReplyInfo* mutable_externaladreply();
  void set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply);
  private:
  const ::proto::ContextInfo_ExternalAdReplyInfo& _internal_externaladreply() const;
  ::proto::ContextInfo_ExternalAdReplyInfo* _internal_mutable_externaladreply();
  public:
  void unsafe_arena_set_allocated_externaladreply(
      ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply);
  ::proto::ContextInfo_ExternalAdReplyInfo* unsafe_arena_release_externaladreply();

  // optional .proto.DisappearingMode disappearingMode = 32;
  bool has_disappearingmode() const;
  private:
  bool _internal_has_disappearingmode() const;
  public:
  void clear_disappearingmode();
  const ::proto::DisappearingMode& disappearingmode() const;
  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
  ::proto::DisappearingMode* mutable_disappearingmode();
  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
  private:
  const ::proto::DisappearingMode& _internal_disappearingmode() const;
  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
  public:
  void unsafe_arena_set_allocated_disappearingmode(
      ::proto::DisappearingMode* disappearingmode);
  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();

  // optional .proto.ActionLink actionLink = 33;
  bool has_actionlink() const;
  private:
  bool _internal_has_actionlink() const;
  public:
  void clear_actionlink();
  const ::proto::ActionLink& actionlink() const;
  PROTOBUF_NODISCARD ::proto::ActionLink* release_actionlink();
  ::proto::ActionLink* mutable_actionlink();
  void set_allocated_actionlink(::proto::ActionLink* actionlink);
  private:
  const ::proto::ActionLink& _internal_actionlink() const;
  ::proto::ActionLink* _internal_mutable_actionlink();
  public:
  void unsafe_arena_set_allocated_actionlink(
      ::proto::ActionLink* actionlink);
  ::proto::ActionLink* unsafe_arena_release_actionlink();

  // optional uint32 conversionDelaySeconds = 20;
  bool has_conversiondelayseconds() const;
  private:
  bool _internal_has_conversiondelayseconds() const;
  public:
  void clear_conversiondelayseconds();
  uint32_t conversiondelayseconds() const;
  void set_conversiondelayseconds(uint32_t value);
  private:
  uint32_t _internal_conversiondelayseconds() const;
  void _internal_set_conversiondelayseconds(uint32_t value);
  public:

  // optional uint32 forwardingScore = 21;
  bool has_forwardingscore() const;
  private:
  bool _internal_has_forwardingscore() const;
  public:
  void clear_forwardingscore();
  uint32_t forwardingscore() const;
  void set_forwardingscore(uint32_t value);
  private:
  uint32_t _internal_forwardingscore() const;
  void _internal_set_forwardingscore(uint32_t value);
  public:

  // optional bool isForwarded = 22;
  bool has_isforwarded() const;
  private:
  bool _internal_has_isforwarded() const;
  public:
  void clear_isforwarded();
  bool isforwarded() const;
  void set_isforwarded(bool value);
  private:
  bool _internal_isforwarded() const;
  void _internal_set_isforwarded(bool value);
  public:

  // optional uint32 expiration = 25;
  bool has_expiration() const;
  private:
  bool _internal_has_expiration() const;
  public:
  void clear_expiration();
  uint32_t expiration() const;
  void set_expiration(uint32_t value);
  private:
  uint32_t _internal_expiration() const;
  void _internal_set_expiration(uint32_t value);
  public:

  // optional int64 ephemeralSettingTimestamp = 26;
  bool has_ephemeralsettingtimestamp() const;
  private:
  bool _internal_has_ephemeralsettingtimestamp() const;
  public:
  void clear_ephemeralsettingtimestamp();
  int64_t ephemeralsettingtimestamp() const;
  void set_ephemeralsettingtimestamp(int64_t value);
  private:
  int64_t _internal_ephemeralsettingtimestamp() const;
  void _internal_set_ephemeralsettingtimestamp(int64_t value);
  public:

  // optional uint32 entryPointConversionDelaySeconds = 31;
  bool has_entrypointconversiondelayseconds() const;
  private:
  bool _internal_has_entrypointconversiondelayseconds() const;
  public:
  void clear_entrypointconversiondelayseconds();
  uint32_t entrypointconversiondelayseconds() const;
  void set_entrypointconversiondelayseconds(uint32_t value);
  private:
  uint32_t _internal_entrypointconversiondelayseconds() const;
  void _internal_set_entrypointconversiondelayseconds(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ContextInfo)
 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> mentionedjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remotejid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeralsharedsecret_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionsource_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entrypointconversionapp_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupsubject_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupjid_;
    ::proto::Message* quotedmessage_;
    ::proto::ContextInfo_AdReplyInfo* quotedad_;
    ::proto::MessageKey* placeholderkey_;
    ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply_;
    ::proto::DisappearingMode* disappearingmode_;
    ::proto::ActionLink* actionlink_;
    uint32_t conversiondelayseconds_;
    uint32_t forwardingscore_;
    bool isforwarded_;
    uint32_t expiration_;
    int64_t ephemeralsettingtimestamp_;
    uint32_t entrypointconversiondelayseconds_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Conversation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Conversation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Conversation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Conversation& from) {
    Conversation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef Conversation_EndOfHistoryTransferType EndOfHistoryTransferType;
  static constexpr EndOfHistoryTransferType COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY =
    Conversation_EndOfHistoryTransferType_COMPLETE_BUT_MORE_MESSAGES_REMAIN_ON_PRIMARY;
  static constexpr EndOfHistoryTransferType COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY =
    Conversation_EndOfHistoryTransferType_COMPLETE_AND_NO_MORE_MESSAGE_REMAIN_ON_PRIMARY;
  static inline bool EndOfHistoryTransferType_IsValid(int value) {
    return Conversation_EndOfHistoryTransferType_IsValid(value);
  }
  static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MIN =
    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MIN;
  static constexpr EndOfHistoryTransferType EndOfHistoryTransferType_MAX =
    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_MAX;
  static constexpr int EndOfHistoryTransferType_ARRAYSIZE =
    Conversation_EndOfHistoryTransferType_EndOfHistoryTransferType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  EndOfHistoryTransferType_descriptor() {
    return Conversation_EndOfHistoryTransferType_descriptor();
  }
  template<typename T>
  static inline const std::string& EndOfHistoryTransferType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EndOfHistoryTransferType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EndOfHistoryTransferType_Name.");
    return Conversation_EndOfHistoryTransferType_Name(enum_t_value);
  }
  static inline bool EndOfHistoryTransferType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EndOfHistoryTransferType* value) {
    return Conversation_EndOfHistoryTransferType_Parse(name, value);
  }

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

  enum : int {
    kMessagesFieldNumber = 2,
    kParticipantFieldNumber = 20,
    kIdFieldNumber = 1,
    kNewJidFieldNumber = 3,
    kOldJidFieldNumber = 4,
    kNameFieldNumber = 13,
    kPHashFieldNumber = 14,
    kTcTokenFieldNumber = 21,
    kContactPrimaryIdentityKeyFieldNumber = 23,
    kCreatedByFieldNumber = 32,
    kDescriptionFieldNumber = 33,
    kParentGroupIdFieldNumber = 37,
    kDisplayNameFieldNumber = 38,
    kPnJidFieldNumber = 39,
    kDisappearingModeFieldNumber = 17,
    kWallpaperFieldNumber = 26,
    kLastMsgTimestampFieldNumber = 5,
    kUnreadCountFieldNumber = 6,
    kEphemeralExpirationFieldNumber = 9,
    kEphemeralSettingTimestampFieldNumber = 10,
    kEndOfHistoryTransferTypeFieldNumber = 11,
    kReadOnlyFieldNumber = 7,
    kEndOfHistoryTransferFieldNumber = 8,
    kNotSpamFieldNumber = 15,
    kArchivedFieldNumber = 16,
    kConversationTimestampFieldNumber = 12,
    kUnreadMentionCountFieldNumber = 18,
    kPinnedFieldNumber = 24,
    kTcTokenTimestampFieldNumber = 22,
    kMuteEndTimeFieldNumber = 25,
    kMediaVisibilityFieldNumber = 27,
    kMarkedAsUnreadFieldNumber = 19,
    kSuspendedFieldNumber = 29,
    kTerminatedFieldNumber = 30,
    kSupportFieldNumber = 34,
    kTcTokenSenderTimestampFieldNumber = 28,
    kCreatedAtFieldNumber = 31,
    kIsParentGroupFieldNumber = 35,
    kIsDefaultSubgroupFieldNumber = 36,
    kSelfPnExposedFieldNumber = 40,
  };
  // repeated .proto.HistorySyncMsg messages = 2;
  int messages_size() const;
  private:
  int _internal_messages_size() const;
  public:
  void clear_messages();
  ::proto::HistorySyncMsg* mutable_messages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >*
      mutable_messages();
  private:
  const ::proto::HistorySyncMsg& _internal_messages(int index) const;
  ::proto::HistorySyncMsg* _internal_add_messages();
  public:
  const ::proto::HistorySyncMsg& messages(int index) const;
  ::proto::HistorySyncMsg* add_messages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >&
      messages() const;

  // repeated .proto.GroupParticipant participant = 20;
  int participant_size() const;
  private:
  int _internal_participant_size() const;
  public:
  void clear_participant();
  ::proto::GroupParticipant* mutable_participant(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >*
      mutable_participant();
  private:
  const ::proto::GroupParticipant& _internal_participant(int index) const;
  ::proto::GroupParticipant* _internal_add_participant();
  public:
  const ::proto::GroupParticipant& participant(int index) const;
  ::proto::GroupParticipant* add_participant();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >&
      participant() const;

  // required string id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional string newJid = 3;
  bool has_newjid() const;
  private:
  bool _internal_has_newjid() const;
  public:
  void clear_newjid();
  const std::string& newjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_newjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_newjid();
  PROTOBUF_NODISCARD std::string* release_newjid();
  void set_allocated_newjid(std::string* newjid);
  private:
  const std::string& _internal_newjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_newjid(const std::string& value);
  std::string* _internal_mutable_newjid();
  public:

  // optional string oldJid = 4;
  bool has_oldjid() const;
  private:
  bool _internal_has_oldjid() const;
  public:
  void clear_oldjid();
  const std::string& oldjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oldjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oldjid();
  PROTOBUF_NODISCARD std::string* release_oldjid();
  void set_allocated_oldjid(std::string* oldjid);
  private:
  const std::string& _internal_oldjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldjid(const std::string& value);
  std::string* _internal_mutable_oldjid();
  public:

  // optional string name = 13;
  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:

  // optional string pHash = 14;
  bool has_phash() const;
  private:
  bool _internal_has_phash() const;
  public:
  void clear_phash();
  const std::string& phash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_phash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_phash();
  PROTOBUF_NODISCARD std::string* release_phash();
  void set_allocated_phash(std::string* phash);
  private:
  const std::string& _internal_phash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value);
  std::string* _internal_mutable_phash();
  public:

  // optional bytes tcToken = 21;
  bool has_tctoken() const;
  private:
  bool _internal_has_tctoken() const;
  public:
  void clear_tctoken();
  const std::string& tctoken() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_tctoken(ArgT0&& arg0, ArgT... args);
  std::string* mutable_tctoken();
  PROTOBUF_NODISCARD std::string* release_tctoken();
  void set_allocated_tctoken(std::string* tctoken);
  private:
  const std::string& _internal_tctoken() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_tctoken(const std::string& value);
  std::string* _internal_mutable_tctoken();
  public:

  // optional bytes contactPrimaryIdentityKey = 23;
  bool has_contactprimaryidentitykey() const;
  private:
  bool _internal_has_contactprimaryidentitykey() const;
  public:
  void clear_contactprimaryidentitykey();
  const std::string& contactprimaryidentitykey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contactprimaryidentitykey();
  PROTOBUF_NODISCARD std::string* release_contactprimaryidentitykey();
  void set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey);
  private:
  const std::string& _internal_contactprimaryidentitykey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contactprimaryidentitykey(const std::string& value);
  std::string* _internal_mutable_contactprimaryidentitykey();
  public:

  // optional string createdBy = 32;
  bool has_createdby() const;
  private:
  bool _internal_has_createdby() const;
  public:
  void clear_createdby();
  const std::string& createdby() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_createdby(ArgT0&& arg0, ArgT... args);
  std::string* mutable_createdby();
  PROTOBUF_NODISCARD std::string* release_createdby();
  void set_allocated_createdby(std::string* createdby);
  private:
  const std::string& _internal_createdby() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_createdby(const std::string& value);
  std::string* _internal_mutable_createdby();
  public:

  // optional string description = 33;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional string parentGroupId = 37;
  bool has_parentgroupid() const;
  private:
  bool _internal_has_parentgroupid() const;
  public:
  void clear_parentgroupid();
  const std::string& parentgroupid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_parentgroupid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_parentgroupid();
  PROTOBUF_NODISCARD std::string* release_parentgroupid();
  void set_allocated_parentgroupid(std::string* parentgroupid);
  private:
  const std::string& _internal_parentgroupid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_parentgroupid(const std::string& value);
  std::string* _internal_mutable_parentgroupid();
  public:

  // optional string displayName = 38;
  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 pnJid = 39;
  bool has_pnjid() const;
  private:
  bool _internal_has_pnjid() const;
  public:
  void clear_pnjid();
  const std::string& pnjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pnjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pnjid();
  PROTOBUF_NODISCARD std::string* release_pnjid();
  void set_allocated_pnjid(std::string* pnjid);
  private:
  const std::string& _internal_pnjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pnjid(const std::string& value);
  std::string* _internal_mutable_pnjid();
  public:

  // optional .proto.DisappearingMode disappearingMode = 17;
  bool has_disappearingmode() const;
  private:
  bool _internal_has_disappearingmode() const;
  public:
  void clear_disappearingmode();
  const ::proto::DisappearingMode& disappearingmode() const;
  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
  ::proto::DisappearingMode* mutable_disappearingmode();
  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
  private:
  const ::proto::DisappearingMode& _internal_disappearingmode() const;
  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
  public:
  void unsafe_arena_set_allocated_disappearingmode(
      ::proto::DisappearingMode* disappearingmode);
  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();

  // optional .proto.WallpaperSettings wallpaper = 26;
  bool has_wallpaper() const;
  private:
  bool _internal_has_wallpaper() const;
  public:
  void clear_wallpaper();
  const ::proto::WallpaperSettings& wallpaper() const;
  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_wallpaper();
  ::proto::WallpaperSettings* mutable_wallpaper();
  void set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper);
  private:
  const ::proto::WallpaperSettings& _internal_wallpaper() const;
  ::proto::WallpaperSettings* _internal_mutable_wallpaper();
  public:
  void unsafe_arena_set_allocated_wallpaper(
      ::proto::WallpaperSettings* wallpaper);
  ::proto::WallpaperSettings* unsafe_arena_release_wallpaper();

  // optional uint64 lastMsgTimestamp = 5;
  bool has_lastmsgtimestamp() const;
  private:
  bool _internal_has_lastmsgtimestamp() const;
  public:
  void clear_lastmsgtimestamp();
  uint64_t lastmsgtimestamp() const;
  void set_lastmsgtimestamp(uint64_t value);
  private:
  uint64_t _internal_lastmsgtimestamp() const;
  void _internal_set_lastmsgtimestamp(uint64_t value);
  public:

  // optional uint32 unreadCount = 6;
  bool has_unreadcount() const;
  private:
  bool _internal_has_unreadcount() const;
  public:
  void clear_unreadcount();
  uint32_t unreadcount() const;
  void set_unreadcount(uint32_t value);
  private:
  uint32_t _internal_unreadcount() const;
  void _internal_set_unreadcount(uint32_t value);
  public:

  // optional uint32 ephemeralExpiration = 9;
  bool has_ephemeralexpiration() const;
  private:
  bool _internal_has_ephemeralexpiration() const;
  public:
  void clear_ephemeralexpiration();
  uint32_t ephemeralexpiration() const;
  void set_ephemeralexpiration(uint32_t value);
  private:
  uint32_t _internal_ephemeralexpiration() const;
  void _internal_set_ephemeralexpiration(uint32_t value);
  public:

  // optional int64 ephemeralSettingTimestamp = 10;
  bool has_ephemeralsettingtimestamp() const;
  private:
  bool _internal_has_ephemeralsettingtimestamp() const;
  public:
  void clear_ephemeralsettingtimestamp();
  int64_t ephemeralsettingtimestamp() const;
  void set_ephemeralsettingtimestamp(int64_t value);
  private:
  int64_t _internal_ephemeralsettingtimestamp() const;
  void _internal_set_ephemeralsettingtimestamp(int64_t value);
  public:

  // optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
  bool has_endofhistorytransfertype() const;
  private:
  bool _internal_has_endofhistorytransfertype() const;
  public:
  void clear_endofhistorytransfertype();
  ::proto::Conversation_EndOfHistoryTransferType endofhistorytransfertype() const;
  void set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value);
  private:
  ::proto::Conversation_EndOfHistoryTransferType _internal_endofhistorytransfertype() const;
  void _internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value);
  public:

  // optional bool readOnly = 7;
  bool has_readonly() const;
  private:
  bool _internal_has_readonly() const;
  public:
  void clear_readonly();
  bool readonly() const;
  void set_readonly(bool value);
  private:
  bool _internal_readonly() const;
  void _internal_set_readonly(bool value);
  public:

  // optional bool endOfHistoryTransfer = 8;
  bool has_endofhistorytransfer() const;
  private:
  bool _internal_has_endofhistorytransfer() const;
  public:
  void clear_endofhistorytransfer();
  bool endofhistorytransfer() const;
  void set_endofhistorytransfer(bool value);
  private:
  bool _internal_endofhistorytransfer() const;
  void _internal_set_endofhistorytransfer(bool value);
  public:

  // optional bool notSpam = 15;
  bool has_notspam() const;
  private:
  bool _internal_has_notspam() const;
  public:
  void clear_notspam();
  bool notspam() const;
  void set_notspam(bool value);
  private:
  bool _internal_notspam() const;
  void _internal_set_notspam(bool value);
  public:

  // optional bool archived = 16;
  bool has_archived() const;
  private:
  bool _internal_has_archived() const;
  public:
  void clear_archived();
  bool archived() const;
  void set_archived(bool value);
  private:
  bool _internal_archived() const;
  void _internal_set_archived(bool value);
  public:

  // optional uint64 conversationTimestamp = 12;
  bool has_conversationtimestamp() const;
  private:
  bool _internal_has_conversationtimestamp() const;
  public:
  void clear_conversationtimestamp();
  uint64_t conversationtimestamp() const;
  void set_conversationtimestamp(uint64_t value);
  private:
  uint64_t _internal_conversationtimestamp() const;
  void _internal_set_conversationtimestamp(uint64_t value);
  public:

  // optional uint32 unreadMentionCount = 18;
  bool has_unreadmentioncount() const;
  private:
  bool _internal_has_unreadmentioncount() const;
  public:
  void clear_unreadmentioncount();
  uint32_t unreadmentioncount() const;
  void set_unreadmentioncount(uint32_t value);
  private:
  uint32_t _internal_unreadmentioncount() const;
  void _internal_set_unreadmentioncount(uint32_t value);
  public:

  // optional uint32 pinned = 24;
  bool has_pinned() const;
  private:
  bool _internal_has_pinned() const;
  public:
  void clear_pinned();
  uint32_t pinned() const;
  void set_pinned(uint32_t value);
  private:
  uint32_t _internal_pinned() const;
  void _internal_set_pinned(uint32_t value);
  public:

  // optional uint64 tcTokenTimestamp = 22;
  bool has_tctokentimestamp() const;
  private:
  bool _internal_has_tctokentimestamp() const;
  public:
  void clear_tctokentimestamp();
  uint64_t tctokentimestamp() const;
  void set_tctokentimestamp(uint64_t value);
  private:
  uint64_t _internal_tctokentimestamp() const;
  void _internal_set_tctokentimestamp(uint64_t value);
  public:

  // optional uint64 muteEndTime = 25;
  bool has_muteendtime() const;
  private:
  bool _internal_has_muteendtime() const;
  public:
  void clear_muteendtime();
  uint64_t muteendtime() const;
  void set_muteendtime(uint64_t value);
  private:
  uint64_t _internal_muteendtime() const;
  void _internal_set_muteendtime(uint64_t value);
  public:

  // optional .proto.MediaVisibility mediaVisibility = 27;
  bool has_mediavisibility() const;
  private:
  bool _internal_has_mediavisibility() const;
  public:
  void clear_mediavisibility();
  ::proto::MediaVisibility mediavisibility() const;
  void set_mediavisibility(::proto::MediaVisibility value);
  private:
  ::proto::MediaVisibility _internal_mediavisibility() const;
  void _internal_set_mediavisibility(::proto::MediaVisibility value);
  public:

  // optional bool markedAsUnread = 19;
  bool has_markedasunread() const;
  private:
  bool _internal_has_markedasunread() const;
  public:
  void clear_markedasunread();
  bool markedasunread() const;
  void set_markedasunread(bool value);
  private:
  bool _internal_markedasunread() const;
  void _internal_set_markedasunread(bool value);
  public:

  // optional bool suspended = 29;
  bool has_suspended() const;
  private:
  bool _internal_has_suspended() const;
  public:
  void clear_suspended();
  bool suspended() const;
  void set_suspended(bool value);
  private:
  bool _internal_suspended() const;
  void _internal_set_suspended(bool value);
  public:

  // optional bool terminated = 30;
  bool has_terminated() const;
  private:
  bool _internal_has_terminated() const;
  public:
  void clear_terminated();
  bool terminated() const;
  void set_terminated(bool value);
  private:
  bool _internal_terminated() const;
  void _internal_set_terminated(bool value);
  public:

  // optional bool support = 34;
  bool has_support() const;
  private:
  bool _internal_has_support() const;
  public:
  void clear_support();
  bool support() const;
  void set_support(bool value);
  private:
  bool _internal_support() const;
  void _internal_set_support(bool value);
  public:

  // optional uint64 tcTokenSenderTimestamp = 28;
  bool has_tctokensendertimestamp() const;
  private:
  bool _internal_has_tctokensendertimestamp() const;
  public:
  void clear_tctokensendertimestamp();
  uint64_t tctokensendertimestamp() const;
  void set_tctokensendertimestamp(uint64_t value);
  private:
  uint64_t _internal_tctokensendertimestamp() const;
  void _internal_set_tctokensendertimestamp(uint64_t value);
  public:

  // optional uint64 createdAt = 31;
  bool has_createdat() const;
  private:
  bool _internal_has_createdat() const;
  public:
  void clear_createdat();
  uint64_t createdat() const;
  void set_createdat(uint64_t value);
  private:
  uint64_t _internal_createdat() const;
  void _internal_set_createdat(uint64_t value);
  public:

  // optional bool isParentGroup = 35;
  bool has_isparentgroup() const;
  private:
  bool _internal_has_isparentgroup() const;
  public:
  void clear_isparentgroup();
  bool isparentgroup() const;
  void set_isparentgroup(bool value);
  private:
  bool _internal_isparentgroup() const;
  void _internal_set_isparentgroup(bool value);
  public:

  // optional bool isDefaultSubgroup = 36;
  bool has_isdefaultsubgroup() const;
  private:
  bool _internal_has_isdefaultsubgroup() const;
  public:
  void clear_isdefaultsubgroup();
  bool isdefaultsubgroup() const;
  void set_isdefaultsubgroup(bool value);
  private:
  bool _internal_isdefaultsubgroup() const;
  void _internal_set_isdefaultsubgroup(bool value);
  public:

  // optional bool selfPnExposed = 40;
  bool has_selfpnexposed() const;
  private:
  bool _internal_has_selfpnexposed() const;
  public:
  void clear_selfpnexposed();
  bool selfpnexposed() const;
  void set_selfpnexposed(bool value);
  private:
  bool _internal_selfpnexposed() const;
  void _internal_set_selfpnexposed(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Conversation)
 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<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg > messages_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant > participant_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oldjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tctoken_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contactprimaryidentitykey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr createdby_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parentgroupid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pnjid_;
    ::proto::DisappearingMode* disappearingmode_;
    ::proto::WallpaperSettings* wallpaper_;
    uint64_t lastmsgtimestamp_;
    uint32_t unreadcount_;
    uint32_t ephemeralexpiration_;
    int64_t ephemeralsettingtimestamp_;
    int endofhistorytransfertype_;
    bool readonly_;
    bool endofhistorytransfer_;
    bool notspam_;
    bool archived_;
    uint64_t conversationtimestamp_;
    uint32_t unreadmentioncount_;
    uint32_t pinned_;
    uint64_t tctokentimestamp_;
    uint64_t muteendtime_;
    int mediavisibility_;
    bool markedasunread_;
    bool suspended_;
    bool terminated_;
    bool support_;
    uint64_t tctokensendertimestamp_;
    uint64_t createdat_;
    bool isparentgroup_;
    bool isdefaultsubgroup_;
    bool selfpnexposed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  DeviceListMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeviceListMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceListMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DeviceListMetadata& from) {
    DeviceListMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kSenderKeyIndexesFieldNumber = 3,
    kRecipientKeyIndexesFieldNumber = 10,
    kSenderKeyHashFieldNumber = 1,
    kRecipientKeyHashFieldNumber = 8,
    kSenderTimestampFieldNumber = 2,
    kRecipientTimestampFieldNumber = 9,
  };
  // repeated uint32 senderKeyIndexes = 3 [packed = true];
  int senderkeyindexes_size() const;
  private:
  int _internal_senderkeyindexes_size() const;
  public:
  void clear_senderkeyindexes();
  private:
  uint32_t _internal_senderkeyindexes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_senderkeyindexes() const;
  void _internal_add_senderkeyindexes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_senderkeyindexes();
  public:
  uint32_t senderkeyindexes(int index) const;
  void set_senderkeyindexes(int index, uint32_t value);
  void add_senderkeyindexes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      senderkeyindexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_senderkeyindexes();

  // repeated uint32 recipientKeyIndexes = 10 [packed = true];
  int recipientkeyindexes_size() const;
  private:
  int _internal_recipientkeyindexes_size() const;
  public:
  void clear_recipientkeyindexes();
  private:
  uint32_t _internal_recipientkeyindexes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_recipientkeyindexes() const;
  void _internal_add_recipientkeyindexes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_recipientkeyindexes();
  public:
  uint32_t recipientkeyindexes(int index) const;
  void set_recipientkeyindexes(int index, uint32_t value);
  void add_recipientkeyindexes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      recipientkeyindexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_recipientkeyindexes();

  // optional bytes senderKeyHash = 1;
  bool has_senderkeyhash() const;
  private:
  bool _internal_has_senderkeyhash() const;
  public:
  void clear_senderkeyhash();
  const std::string& senderkeyhash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_senderkeyhash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_senderkeyhash();
  PROTOBUF_NODISCARD std::string* release_senderkeyhash();
  void set_allocated_senderkeyhash(std::string* senderkeyhash);
  private:
  const std::string& _internal_senderkeyhash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_senderkeyhash(const std::string& value);
  std::string* _internal_mutable_senderkeyhash();
  public:

  // optional bytes recipientKeyHash = 8;
  bool has_recipientkeyhash() const;
  private:
  bool _internal_has_recipientkeyhash() const;
  public:
  void clear_recipientkeyhash();
  const std::string& recipientkeyhash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_recipientkeyhash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_recipientkeyhash();
  PROTOBUF_NODISCARD std::string* release_recipientkeyhash();
  void set_allocated_recipientkeyhash(std::string* recipientkeyhash);
  private:
  const std::string& _internal_recipientkeyhash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_recipientkeyhash(const std::string& value);
  std::string* _internal_mutable_recipientkeyhash();
  public:

  // optional uint64 senderTimestamp = 2;
  bool has_sendertimestamp() const;
  private:
  bool _internal_has_sendertimestamp() const;
  public:
  void clear_sendertimestamp();
  uint64_t sendertimestamp() const;
  void set_sendertimestamp(uint64_t value);
  private:
  uint64_t _internal_sendertimestamp() const;
  void _internal_set_sendertimestamp(uint64_t value);
  public:

  // optional uint64 recipientTimestamp = 9;
  bool has_recipienttimestamp() const;
  private:
  bool _internal_has_recipienttimestamp() const;
  public:
  void clear_recipienttimestamp();
  uint64_t recipienttimestamp() const;
  void set_recipienttimestamp(uint64_t value);
  private:
  uint64_t _internal_recipienttimestamp() const;
  void _internal_set_recipienttimestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.DeviceListMetadata)
 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< uint32_t > senderkeyindexes_;
    mutable std::atomic<int> _senderkeyindexes_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > recipientkeyindexes_;
    mutable std::atomic<int> _recipientkeyindexes_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr senderkeyhash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr recipientkeyhash_;
    uint64_t sendertimestamp_;
    uint64_t recipienttimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class DeviceProps_AppVersion final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.DeviceProps.AppVersion) */ {
 public:
  inline DeviceProps_AppVersion() : DeviceProps_AppVersion(nullptr) {}
  ~DeviceProps_AppVersion() override;
  explicit PROTOBUF_CONSTEXPR DeviceProps_AppVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  DeviceProps_AppVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeviceProps_AppVersion>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceProps_AppVersion& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DeviceProps_AppVersion& from) {
    DeviceProps_AppVersion::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kPrimaryFieldNumber = 1,
    kSecondaryFieldNumber = 2,
    kTertiaryFieldNumber = 3,
    kQuaternaryFieldNumber = 4,
    kQuinaryFieldNumber = 5,
  };
  // optional uint32 primary = 1;
  bool has_primary() const;
  private:
  bool _internal_has_primary() const;
  public:
  void clear_primary();
  uint32_t primary() const;
  void set_primary(uint32_t value);
  private:
  uint32_t _internal_primary() const;
  void _internal_set_primary(uint32_t value);
  public:

  // optional uint32 secondary = 2;
  bool has_secondary() const;
  private:
  bool _internal_has_secondary() const;
  public:
  void clear_secondary();
  uint32_t secondary() const;
  void set_secondary(uint32_t value);
  private:
  uint32_t _internal_secondary() const;
  void _internal_set_secondary(uint32_t value);
  public:

  // optional uint32 tertiary = 3;
  bool has_tertiary() const;
  private:
  bool _internal_has_tertiary() const;
  public:
  void clear_tertiary();
  uint32_t tertiary() const;
  void set_tertiary(uint32_t value);
  private:
  uint32_t _internal_tertiary() const;
  void _internal_set_tertiary(uint32_t value);
  public:

  // optional uint32 quaternary = 4;
  bool has_quaternary() const;
  private:
  bool _internal_has_quaternary() const;
  public:
  void clear_quaternary();
  uint32_t quaternary() const;
  void set_quaternary(uint32_t value);
  private:
  uint32_t _internal_quaternary() const;
  void _internal_set_quaternary(uint32_t value);
  public:

  // optional uint32 quinary = 5;
  bool has_quinary() const;
  private:
  bool _internal_has_quinary() const;
  public:
  void clear_quinary();
  uint32_t quinary() const;
  void set_quinary(uint32_t value);
  private:
  uint32_t _internal_quinary() const;
  void _internal_set_quinary(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.DeviceProps.AppVersion)
 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_;
    uint32_t primary_;
    uint32_t secondary_;
    uint32_t tertiary_;
    uint32_t quaternary_;
    uint32_t quinary_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  DeviceProps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DeviceProps>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DeviceProps& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DeviceProps& from) {
    DeviceProps::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef DeviceProps_AppVersion AppVersion;

  typedef DeviceProps_PlatformType PlatformType;
  static constexpr PlatformType UNKNOWN =
    DeviceProps_PlatformType_UNKNOWN;
  static constexpr PlatformType CHROME =
    DeviceProps_PlatformType_CHROME;
  static constexpr PlatformType FIREFOX =
    DeviceProps_PlatformType_FIREFOX;
  static constexpr PlatformType IE =
    DeviceProps_PlatformType_IE;
  static constexpr PlatformType OPERA =
    DeviceProps_PlatformType_OPERA;
  static constexpr PlatformType SAFARI =
    DeviceProps_PlatformType_SAFARI;
  static constexpr PlatformType EDGE =
    DeviceProps_PlatformType_EDGE;
  static constexpr PlatformType DESKTOP =
    DeviceProps_PlatformType_DESKTOP;
  static constexpr PlatformType IPAD =
    DeviceProps_PlatformType_IPAD;
  static constexpr PlatformType ANDROID_TABLET =
    DeviceProps_PlatformType_ANDROID_TABLET;
  static constexpr PlatformType OHANA =
    DeviceProps_PlatformType_OHANA;
  static constexpr PlatformType ALOHA =
    DeviceProps_PlatformType_ALOHA;
  static constexpr PlatformType CATALINA =
    DeviceProps_PlatformType_CATALINA;
  static constexpr PlatformType TCL_TV =
    DeviceProps_PlatformType_TCL_TV;
  static inline bool PlatformType_IsValid(int value) {
    return DeviceProps_PlatformType_IsValid(value);
  }
  static constexpr PlatformType PlatformType_MIN =
    DeviceProps_PlatformType_PlatformType_MIN;
  static constexpr PlatformType PlatformType_MAX =
    DeviceProps_PlatformType_PlatformType_MAX;
  static constexpr int PlatformType_ARRAYSIZE =
    DeviceProps_PlatformType_PlatformType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PlatformType_descriptor() {
    return DeviceProps_PlatformType_descriptor();
  }
  template<typename T>
  static inline const std::string& PlatformType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PlatformType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PlatformType_Name.");
    return DeviceProps_PlatformType_Name(enum_t_value);
  }
  static inline bool PlatformType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PlatformType* value) {
    return DeviceProps_PlatformType_Parse(name, value);
  }

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

  enum : int {
    kOsFieldNumber = 1,
    kVersionFieldNumber = 2,
    kPlatformTypeFieldNumber = 3,
    kRequireFullSyncFieldNumber = 4,
  };
  // optional string os = 1;
  bool has_os() const;
  private:
  bool _internal_has_os() const;
  public:
  void clear_os();
  const std::string& os() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_os(ArgT0&& arg0, ArgT... args);
  std::string* mutable_os();
  PROTOBUF_NODISCARD std::string* release_os();
  void set_allocated_os(std::string* os);
  private:
  const std::string& _internal_os() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_os(const std::string& value);
  std::string* _internal_mutable_os();
  public:

  // optional .proto.DeviceProps.AppVersion version = 2;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const ::proto::DeviceProps_AppVersion& version() const;
  PROTOBUF_NODISCARD ::proto::DeviceProps_AppVersion* release_version();
  ::proto::DeviceProps_AppVersion* mutable_version();
  void set_allocated_version(::proto::DeviceProps_AppVersion* version);
  private:
  const ::proto::DeviceProps_AppVersion& _internal_version() const;
  ::proto::DeviceProps_AppVersion* _internal_mutable_version();
  public:
  void unsafe_arena_set_allocated_version(
      ::proto::DeviceProps_AppVersion* version);
  ::proto::DeviceProps_AppVersion* unsafe_arena_release_version();

  // optional .proto.DeviceProps.PlatformType platformType = 3;
  bool has_platformtype() const;
  private:
  bool _internal_has_platformtype() const;
  public:
  void clear_platformtype();
  ::proto::DeviceProps_PlatformType platformtype() const;
  void set_platformtype(::proto::DeviceProps_PlatformType value);
  private:
  ::proto::DeviceProps_PlatformType _internal_platformtype() const;
  void _internal_set_platformtype(::proto::DeviceProps_PlatformType value);
  public:

  // optional bool requireFullSync = 4;
  bool has_requirefullsync() const;
  private:
  bool _internal_has_requirefullsync() const;
  public:
  void clear_requirefullsync();
  bool requirefullsync() const;
  void set_requirefullsync(bool value);
  private:
  bool _internal_requirefullsync() const;
  void _internal_set_requirefullsync(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.DeviceProps)
 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 os_;
    ::proto::DeviceProps_AppVersion* version_;
    int platformtype_;
    bool requirefullsync_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  DisappearingMode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DisappearingMode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DisappearingMode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const DisappearingMode& from) {
    DisappearingMode::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef DisappearingMode_Initiator Initiator;
  static constexpr Initiator CHANGED_IN_CHAT =
    DisappearingMode_Initiator_CHANGED_IN_CHAT;
  static constexpr Initiator INITIATED_BY_ME =
    DisappearingMode_Initiator_INITIATED_BY_ME;
  static constexpr Initiator INITIATED_BY_OTHER =
    DisappearingMode_Initiator_INITIATED_BY_OTHER;
  static inline bool Initiator_IsValid(int value) {
    return DisappearingMode_Initiator_IsValid(value);
  }
  static constexpr Initiator Initiator_MIN =
    DisappearingMode_Initiator_Initiator_MIN;
  static constexpr Initiator Initiator_MAX =
    DisappearingMode_Initiator_Initiator_MAX;
  static constexpr int Initiator_ARRAYSIZE =
    DisappearingMode_Initiator_Initiator_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Initiator_descriptor() {
    return DisappearingMode_Initiator_descriptor();
  }
  template<typename T>
  static inline const std::string& Initiator_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Initiator>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Initiator_Name.");
    return DisappearingMode_Initiator_Name(enum_t_value);
  }
  static inline bool Initiator_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Initiator* value) {
    return DisappearingMode_Initiator_Parse(name, value);
  }

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

  enum : int {
    kInitiatorFieldNumber = 1,
  };
  // optional .proto.DisappearingMode.Initiator initiator = 1;
  bool has_initiator() const;
  private:
  bool _internal_has_initiator() const;
  public:
  void clear_initiator();
  ::proto::DisappearingMode_Initiator initiator() const;
  void set_initiator(::proto::DisappearingMode_Initiator value);
  private:
  ::proto::DisappearingMode_Initiator _internal_initiator() const;
  void _internal_set_initiator(::proto::DisappearingMode_Initiator value);
  public:

  // @@protoc_insertion_point(class_scope:proto.DisappearingMode)
 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_;
    int initiator_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  EphemeralSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<EphemeralSetting>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const EphemeralSetting& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const EphemeralSetting& from) {
    EphemeralSetting::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

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

  // optional sfixed32 duration = 1;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  int32_t duration() const;
  void set_duration(int32_t value);
  private:
  int32_t _internal_duration() const;
  void _internal_set_duration(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.EphemeralSetting)
 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_;
    int64_t timestamp_;
    int32_t duration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ExitCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExitCode>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExitCode& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExitCode& from) {
    ExitCode::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kTextFieldNumber = 2,
    kCodeFieldNumber = 1,
  };
  // optional string text = 2;
  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:

  // optional uint64 code = 1;
  bool has_code() const;
  private:
  bool _internal_has_code() const;
  public:
  void clear_code();
  uint64_t code() const;
  void set_code(uint64_t value);
  private:
  uint64_t _internal_code() const;
  void _internal_set_code(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ExitCode)
 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 text_;
    uint64_t code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  ExternalBlobReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ExternalBlobReference>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ExternalBlobReference& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ExternalBlobReference& from) {
    ExternalBlobReference::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kMediaKeyFieldNumber = 1,
    kDirectPathFieldNumber = 2,
    kHandleFieldNumber = 3,
    kFileSha256FieldNumber = 5,
    kFileEncSha256FieldNumber = 6,
    kFileSizeBytesFieldNumber = 4,
  };
  // optional bytes mediaKey = 1;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string directPath = 2;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional string handle = 3;
  bool has_handle() const;
  private:
  bool _internal_has_handle() const;
  public:
  void clear_handle();
  const std::string& handle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_handle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_handle();
  PROTOBUF_NODISCARD std::string* release_handle();
  void set_allocated_handle(std::string* handle);
  private:
  const std::string& _internal_handle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_handle(const std::string& value);
  std::string* _internal_mutable_handle();
  public:

  // optional bytes fileSha256 = 5;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes fileEncSha256 = 6;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional uint64 fileSizeBytes = 4;
  bool has_filesizebytes() const;
  private:
  bool _internal_has_filesizebytes() const;
  public:
  void clear_filesizebytes();
  uint64_t filesizebytes() const;
  void set_filesizebytes(uint64_t value);
  private:
  uint64_t _internal_filesizebytes() const;
  void _internal_set_filesizebytes(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.ExternalBlobReference)
 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 mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handle_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    uint64_t filesizebytes_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  GlobalSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GlobalSettings>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GlobalSettings& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GlobalSettings& from) {
    GlobalSettings::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kLightThemeWallpaperFieldNumber = 1,
    kDarkThemeWallpaperFieldNumber = 3,
    kAutoDownloadWiFiFieldNumber = 4,
    kAutoDownloadCellularFieldNumber = 5,
    kAutoDownloadRoamingFieldNumber = 6,
    kMediaVisibilityFieldNumber = 2,
    kShowIndividualNotificationsPreviewFieldNumber = 7,
    kShowGroupNotificationsPreviewFieldNumber = 8,
    kDisappearingModeTimestampFieldNumber = 10,
    kDisappearingModeDurationFieldNumber = 9,
  };
  // optional .proto.WallpaperSettings lightThemeWallpaper = 1;
  bool has_lightthemewallpaper() const;
  private:
  bool _internal_has_lightthemewallpaper() const;
  public:
  void clear_lightthemewallpaper();
  const ::proto::WallpaperSettings& lightthemewallpaper() const;
  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_lightthemewallpaper();
  ::proto::WallpaperSettings* mutable_lightthemewallpaper();
  void set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper);
  private:
  const ::proto::WallpaperSettings& _internal_lightthemewallpaper() const;
  ::proto::WallpaperSettings* _internal_mutable_lightthemewallpaper();
  public:
  void unsafe_arena_set_allocated_lightthemewallpaper(
      ::proto::WallpaperSettings* lightthemewallpaper);
  ::proto::WallpaperSettings* unsafe_arena_release_lightthemewallpaper();

  // optional .proto.WallpaperSettings darkThemeWallpaper = 3;
  bool has_darkthemewallpaper() const;
  private:
  bool _internal_has_darkthemewallpaper() const;
  public:
  void clear_darkthemewallpaper();
  const ::proto::WallpaperSettings& darkthemewallpaper() const;
  PROTOBUF_NODISCARD ::proto::WallpaperSettings* release_darkthemewallpaper();
  ::proto::WallpaperSettings* mutable_darkthemewallpaper();
  void set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper);
  private:
  const ::proto::WallpaperSettings& _internal_darkthemewallpaper() const;
  ::proto::WallpaperSettings* _internal_mutable_darkthemewallpaper();
  public:
  void unsafe_arena_set_allocated_darkthemewallpaper(
      ::proto::WallpaperSettings* darkthemewallpaper);
  ::proto::WallpaperSettings* unsafe_arena_release_darkthemewallpaper();

  // optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
  bool has_autodownloadwifi() const;
  private:
  bool _internal_has_autodownloadwifi() const;
  public:
  void clear_autodownloadwifi();
  const ::proto::AutoDownloadSettings& autodownloadwifi() const;
  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadwifi();
  ::proto::AutoDownloadSettings* mutable_autodownloadwifi();
  void set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi);
  private:
  const ::proto::AutoDownloadSettings& _internal_autodownloadwifi() const;
  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadwifi();
  public:
  void unsafe_arena_set_allocated_autodownloadwifi(
      ::proto::AutoDownloadSettings* autodownloadwifi);
  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadwifi();

  // optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
  bool has_autodownloadcellular() const;
  private:
  bool _internal_has_autodownloadcellular() const;
  public:
  void clear_autodownloadcellular();
  const ::proto::AutoDownloadSettings& autodownloadcellular() const;
  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadcellular();
  ::proto::AutoDownloadSettings* mutable_autodownloadcellular();
  void set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular);
  private:
  const ::proto::AutoDownloadSettings& _internal_autodownloadcellular() const;
  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadcellular();
  public:
  void unsafe_arena_set_allocated_autodownloadcellular(
      ::proto::AutoDownloadSettings* autodownloadcellular);
  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadcellular();

  // optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
  bool has_autodownloadroaming() const;
  private:
  bool _internal_has_autodownloadroaming() const;
  public:
  void clear_autodownloadroaming();
  const ::proto::AutoDownloadSettings& autodownloadroaming() const;
  PROTOBUF_NODISCARD ::proto::AutoDownloadSettings* release_autodownloadroaming();
  ::proto::AutoDownloadSettings* mutable_autodownloadroaming();
  void set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming);
  private:
  const ::proto::AutoDownloadSettings& _internal_autodownloadroaming() const;
  ::proto::AutoDownloadSettings* _internal_mutable_autodownloadroaming();
  public:
  void unsafe_arena_set_allocated_autodownloadroaming(
      ::proto::AutoDownloadSettings* autodownloadroaming);
  ::proto::AutoDownloadSettings* unsafe_arena_release_autodownloadroaming();

  // optional .proto.MediaVisibility mediaVisibility = 2;
  bool has_mediavisibility() const;
  private:
  bool _internal_has_mediavisibility() const;
  public:
  void clear_mediavisibility();
  ::proto::MediaVisibility mediavisibility() const;
  void set_mediavisibility(::proto::MediaVisibility value);
  private:
  ::proto::MediaVisibility _internal_mediavisibility() const;
  void _internal_set_mediavisibility(::proto::MediaVisibility value);
  public:

  // optional bool showIndividualNotificationsPreview = 7;
  bool has_showindividualnotificationspreview() const;
  private:
  bool _internal_has_showindividualnotificationspreview() const;
  public:
  void clear_showindividualnotificationspreview();
  bool showindividualnotificationspreview() const;
  void set_showindividualnotificationspreview(bool value);
  private:
  bool _internal_showindividualnotificationspreview() const;
  void _internal_set_showindividualnotificationspreview(bool value);
  public:

  // optional bool showGroupNotificationsPreview = 8;
  bool has_showgroupnotificationspreview() const;
  private:
  bool _internal_has_showgroupnotificationspreview() const;
  public:
  void clear_showgroupnotificationspreview();
  bool showgroupnotificationspreview() const;
  void set_showgroupnotificationspreview(bool value);
  private:
  bool _internal_showgroupnotificationspreview() const;
  void _internal_set_showgroupnotificationspreview(bool value);
  public:

  // optional int64 disappearingModeTimestamp = 10;
  bool has_disappearingmodetimestamp() const;
  private:
  bool _internal_has_disappearingmodetimestamp() const;
  public:
  void clear_disappearingmodetimestamp();
  int64_t disappearingmodetimestamp() const;
  void set_disappearingmodetimestamp(int64_t value);
  private:
  int64_t _internal_disappearingmodetimestamp() const;
  void _internal_set_disappearingmodetimestamp(int64_t value);
  public:

  // optional int32 disappearingModeDuration = 9;
  bool has_disappearingmodeduration() const;
  private:
  bool _internal_has_disappearingmodeduration() const;
  public:
  void clear_disappearingmodeduration();
  int32_t disappearingmodeduration() const;
  void set_disappearingmodeduration(int32_t value);
  private:
  int32_t _internal_disappearingmodeduration() const;
  void _internal_set_disappearingmodeduration(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.GlobalSettings)
 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_;
    ::proto::WallpaperSettings* lightthemewallpaper_;
    ::proto::WallpaperSettings* darkthemewallpaper_;
    ::proto::AutoDownloadSettings* autodownloadwifi_;
    ::proto::AutoDownloadSettings* autodownloadcellular_;
    ::proto::AutoDownloadSettings* autodownloadroaming_;
    int mediavisibility_;
    bool showindividualnotificationspreview_;
    bool showgroupnotificationspreview_;
    int64_t disappearingmodetimestamp_;
    int32_t disappearingmodeduration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  GroupParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<GroupParticipant>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GroupParticipant& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const GroupParticipant& from) {
    GroupParticipant::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef GroupParticipant_Rank Rank;
  static constexpr Rank REGULAR =
    GroupParticipant_Rank_REGULAR;
  static constexpr Rank ADMIN =
    GroupParticipant_Rank_ADMIN;
  static constexpr Rank SUPERADMIN =
    GroupParticipant_Rank_SUPERADMIN;
  static inline bool Rank_IsValid(int value) {
    return GroupParticipant_Rank_IsValid(value);
  }
  static constexpr Rank Rank_MIN =
    GroupParticipant_Rank_Rank_MIN;
  static constexpr Rank Rank_MAX =
    GroupParticipant_Rank_Rank_MAX;
  static constexpr int Rank_ARRAYSIZE =
    GroupParticipant_Rank_Rank_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Rank_descriptor() {
    return GroupParticipant_Rank_descriptor();
  }
  template<typename T>
  static inline const std::string& Rank_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Rank>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Rank_Name.");
    return GroupParticipant_Rank_Name(enum_t_value);
  }
  static inline bool Rank_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Rank* value) {
    return GroupParticipant_Rank_Parse(name, value);
  }

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

  enum : int {
    kUserJidFieldNumber = 1,
    kRankFieldNumber = 2,
  };
  // required string userJid = 1;
  bool has_userjid() const;
  private:
  bool _internal_has_userjid() const;
  public:
  void clear_userjid();
  const std::string& userjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_userjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_userjid();
  PROTOBUF_NODISCARD std::string* release_userjid();
  void set_allocated_userjid(std::string* userjid);
  private:
  const std::string& _internal_userjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
  std::string* _internal_mutable_userjid();
  public:

  // optional .proto.GroupParticipant.Rank rank = 2;
  bool has_rank() const;
  private:
  bool _internal_has_rank() const;
  public:
  void clear_rank();
  ::proto::GroupParticipant_Rank rank() const;
  void set_rank(::proto::GroupParticipant_Rank value);
  private:
  ::proto::GroupParticipant_Rank _internal_rank() const;
  void _internal_set_rank(::proto::GroupParticipant_Rank value);
  public:

  // @@protoc_insertion_point(class_scope:proto.GroupParticipant)
 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 userjid_;
    int rank_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HandshakeMessage_ClientFinish final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientFinish) */ {
 public:
  inline HandshakeMessage_ClientFinish() : HandshakeMessage_ClientFinish(nullptr) {}
  ~HandshakeMessage_ClientFinish() override;
  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientFinish(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HandshakeMessage_ClientFinish* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HandshakeMessage_ClientFinish>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HandshakeMessage_ClientFinish& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HandshakeMessage_ClientFinish& from) {
    HandshakeMessage_ClientFinish::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kStaticFieldNumber = 1,
    kPayloadFieldNumber = 2,
  };
  // optional bytes static = 1;
  bool has_static_() const;
  private:
  bool _internal_has_static_() const;
  public:
  void clear_static_();
  const std::string& static_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_static_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_static_();
  PROTOBUF_NODISCARD std::string* release_static_();
  void set_allocated_static_(std::string* static_);
  private:
  const std::string& _internal_static_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
  std::string* _internal_mutable_static_();
  public:

  // optional bytes payload = 2;
  bool has_payload() const;
  private:
  bool _internal_has_payload() const;
  public:
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientFinish)
 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 static__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HandshakeMessage_ClientHello final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ClientHello) */ {
 public:
  inline HandshakeMessage_ClientHello() : HandshakeMessage_ClientHello(nullptr) {}
  ~HandshakeMessage_ClientHello() override;
  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ClientHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HandshakeMessage_ClientHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HandshakeMessage_ClientHello>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HandshakeMessage_ClientHello& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HandshakeMessage_ClientHello& from) {
    HandshakeMessage_ClientHello::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kEphemeralFieldNumber = 1,
    kStaticFieldNumber = 2,
    kPayloadFieldNumber = 3,
  };
  // optional bytes ephemeral = 1;
  bool has_ephemeral() const;
  private:
  bool _internal_has_ephemeral() const;
  public:
  void clear_ephemeral();
  const std::string& ephemeral() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ephemeral(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ephemeral();
  PROTOBUF_NODISCARD std::string* release_ephemeral();
  void set_allocated_ephemeral(std::string* ephemeral);
  private:
  const std::string& _internal_ephemeral() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value);
  std::string* _internal_mutable_ephemeral();
  public:

  // optional bytes static = 2;
  bool has_static_() const;
  private:
  bool _internal_has_static_() const;
  public:
  void clear_static_();
  const std::string& static_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_static_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_static_();
  PROTOBUF_NODISCARD std::string* release_static_();
  void set_allocated_static_(std::string* static_);
  private:
  const std::string& _internal_static_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
  std::string* _internal_mutable_static_();
  public:

  // optional bytes payload = 3;
  bool has_payload() const;
  private:
  bool _internal_has_payload() const;
  public:
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ClientHello)
 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 ephemeral_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HandshakeMessage_ServerHello final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HandshakeMessage.ServerHello) */ {
 public:
  inline HandshakeMessage_ServerHello() : HandshakeMessage_ServerHello(nullptr) {}
  ~HandshakeMessage_ServerHello() override;
  explicit PROTOBUF_CONSTEXPR HandshakeMessage_ServerHello(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HandshakeMessage_ServerHello* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HandshakeMessage_ServerHello>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HandshakeMessage_ServerHello& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HandshakeMessage_ServerHello& from) {
    HandshakeMessage_ServerHello::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kEphemeralFieldNumber = 1,
    kStaticFieldNumber = 2,
    kPayloadFieldNumber = 3,
  };
  // optional bytes ephemeral = 1;
  bool has_ephemeral() const;
  private:
  bool _internal_has_ephemeral() const;
  public:
  void clear_ephemeral();
  const std::string& ephemeral() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ephemeral(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ephemeral();
  PROTOBUF_NODISCARD std::string* release_ephemeral();
  void set_allocated_ephemeral(std::string* ephemeral);
  private:
  const std::string& _internal_ephemeral() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral(const std::string& value);
  std::string* _internal_mutable_ephemeral();
  public:

  // optional bytes static = 2;
  bool has_static_() const;
  private:
  bool _internal_has_static_() const;
  public:
  void clear_static_();
  const std::string& static_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_static_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_static_();
  PROTOBUF_NODISCARD std::string* release_static_();
  void set_allocated_static_(std::string* static_);
  private:
  const std::string& _internal_static_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_static_(const std::string& value);
  std::string* _internal_mutable_static_();
  public:

  // optional bytes payload = 3;
  bool has_payload() const;
  private:
  bool _internal_has_payload() const;
  public:
  void clear_payload();
  const std::string& payload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_payload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_payload();
  PROTOBUF_NODISCARD std::string* release_payload();
  void set_allocated_payload(std::string* payload);
  private:
  const std::string& _internal_payload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_payload(const std::string& value);
  std::string* _internal_mutable_payload();
  public:

  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage.ServerHello)
 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 ephemeral_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr static__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HandshakeMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HandshakeMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HandshakeMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HandshakeMessage& from) {
    HandshakeMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef HandshakeMessage_ClientFinish ClientFinish;
  typedef HandshakeMessage_ClientHello ClientHello;
  typedef HandshakeMessage_ServerHello ServerHello;

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

  enum : int {
    kClientHelloFieldNumber = 2,
    kServerHelloFieldNumber = 3,
    kClientFinishFieldNumber = 4,
  };
  // optional .proto.HandshakeMessage.ClientHello clientHello = 2;
  bool has_clienthello() const;
  private:
  bool _internal_has_clienthello() const;
  public:
  void clear_clienthello();
  const ::proto::HandshakeMessage_ClientHello& clienthello() const;
  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientHello* release_clienthello();
  ::proto::HandshakeMessage_ClientHello* mutable_clienthello();
  void set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello);
  private:
  const ::proto::HandshakeMessage_ClientHello& _internal_clienthello() const;
  ::proto::HandshakeMessage_ClientHello* _internal_mutable_clienthello();
  public:
  void unsafe_arena_set_allocated_clienthello(
      ::proto::HandshakeMessage_ClientHello* clienthello);
  ::proto::HandshakeMessage_ClientHello* unsafe_arena_release_clienthello();

  // optional .proto.HandshakeMessage.ServerHello serverHello = 3;
  bool has_serverhello() const;
  private:
  bool _internal_has_serverhello() const;
  public:
  void clear_serverhello();
  const ::proto::HandshakeMessage_ServerHello& serverhello() const;
  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ServerHello* release_serverhello();
  ::proto::HandshakeMessage_ServerHello* mutable_serverhello();
  void set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello);
  private:
  const ::proto::HandshakeMessage_ServerHello& _internal_serverhello() const;
  ::proto::HandshakeMessage_ServerHello* _internal_mutable_serverhello();
  public:
  void unsafe_arena_set_allocated_serverhello(
      ::proto::HandshakeMessage_ServerHello* serverhello);
  ::proto::HandshakeMessage_ServerHello* unsafe_arena_release_serverhello();

  // optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
  bool has_clientfinish() const;
  private:
  bool _internal_has_clientfinish() const;
  public:
  void clear_clientfinish();
  const ::proto::HandshakeMessage_ClientFinish& clientfinish() const;
  PROTOBUF_NODISCARD ::proto::HandshakeMessage_ClientFinish* release_clientfinish();
  ::proto::HandshakeMessage_ClientFinish* mutable_clientfinish();
  void set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish);
  private:
  const ::proto::HandshakeMessage_ClientFinish& _internal_clientfinish() const;
  ::proto::HandshakeMessage_ClientFinish* _internal_mutable_clientfinish();
  public:
  void unsafe_arena_set_allocated_clientfinish(
      ::proto::HandshakeMessage_ClientFinish* clientfinish);
  ::proto::HandshakeMessage_ClientFinish* unsafe_arena_release_clientfinish();

  // @@protoc_insertion_point(class_scope:proto.HandshakeMessage)
 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_;
    ::proto::HandshakeMessage_ClientHello* clienthello_;
    ::proto::HandshakeMessage_ServerHello* serverhello_;
    ::proto::HandshakeMessage_ClientFinish* clientfinish_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HistorySync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HistorySync>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HistorySync& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HistorySync& from) {
    HistorySync::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef HistorySync_HistorySyncType HistorySyncType;
  static constexpr HistorySyncType INITIAL_BOOTSTRAP =
    HistorySync_HistorySyncType_INITIAL_BOOTSTRAP;
  static constexpr HistorySyncType INITIAL_STATUS_V3 =
    HistorySync_HistorySyncType_INITIAL_STATUS_V3;
  static constexpr HistorySyncType FULL =
    HistorySync_HistorySyncType_FULL;
  static constexpr HistorySyncType RECENT =
    HistorySync_HistorySyncType_RECENT;
  static constexpr HistorySyncType PUSH_NAME =
    HistorySync_HistorySyncType_PUSH_NAME;
  static constexpr HistorySyncType UNBLOCKING_DATA =
    HistorySync_HistorySyncType_UNBLOCKING_DATA;
  static inline bool HistorySyncType_IsValid(int value) {
    return HistorySync_HistorySyncType_IsValid(value);
  }
  static constexpr HistorySyncType HistorySyncType_MIN =
    HistorySync_HistorySyncType_HistorySyncType_MIN;
  static constexpr HistorySyncType HistorySyncType_MAX =
    HistorySync_HistorySyncType_HistorySyncType_MAX;
  static constexpr int HistorySyncType_ARRAYSIZE =
    HistorySync_HistorySyncType_HistorySyncType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HistorySyncType_descriptor() {
    return HistorySync_HistorySyncType_descriptor();
  }
  template<typename T>
  static inline const std::string& HistorySyncType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HistorySyncType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HistorySyncType_Name.");
    return HistorySync_HistorySyncType_Name(enum_t_value);
  }
  static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HistorySyncType* value) {
    return HistorySync_HistorySyncType_Parse(name, value);
  }

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

  enum : int {
    kConversationsFieldNumber = 2,
    kStatusV3MessagesFieldNumber = 3,
    kPushnamesFieldNumber = 7,
    kRecentStickersFieldNumber = 11,
    kPastParticipantsFieldNumber = 12,
    kThreadIdUserSecretFieldNumber = 9,
    kGlobalSettingsFieldNumber = 8,
    kSyncTypeFieldNumber = 1,
    kChunkOrderFieldNumber = 5,
    kProgressFieldNumber = 6,
    kThreadDsTimeframeOffsetFieldNumber = 10,
  };
  // repeated .proto.Conversation conversations = 2;
  int conversations_size() const;
  private:
  int _internal_conversations_size() const;
  public:
  void clear_conversations();
  ::proto::Conversation* mutable_conversations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >*
      mutable_conversations();
  private:
  const ::proto::Conversation& _internal_conversations(int index) const;
  ::proto::Conversation* _internal_add_conversations();
  public:
  const ::proto::Conversation& conversations(int index) const;
  ::proto::Conversation* add_conversations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >&
      conversations() const;

  // repeated .proto.WebMessageInfo statusV3Messages = 3;
  int statusv3messages_size() const;
  private:
  int _internal_statusv3messages_size() const;
  public:
  void clear_statusv3messages();
  ::proto::WebMessageInfo* mutable_statusv3messages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
      mutable_statusv3messages();
  private:
  const ::proto::WebMessageInfo& _internal_statusv3messages(int index) const;
  ::proto::WebMessageInfo* _internal_add_statusv3messages();
  public:
  const ::proto::WebMessageInfo& statusv3messages(int index) const;
  ::proto::WebMessageInfo* add_statusv3messages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
      statusv3messages() const;

  // repeated .proto.Pushname pushnames = 7;
  int pushnames_size() const;
  private:
  int _internal_pushnames_size() const;
  public:
  void clear_pushnames();
  ::proto::Pushname* mutable_pushnames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >*
      mutable_pushnames();
  private:
  const ::proto::Pushname& _internal_pushnames(int index) const;
  ::proto::Pushname* _internal_add_pushnames();
  public:
  const ::proto::Pushname& pushnames(int index) const;
  ::proto::Pushname* add_pushnames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >&
      pushnames() const;

  // repeated .proto.StickerMetadata recentStickers = 11;
  int recentstickers_size() const;
  private:
  int _internal_recentstickers_size() const;
  public:
  void clear_recentstickers();
  ::proto::StickerMetadata* mutable_recentstickers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >*
      mutable_recentstickers();
  private:
  const ::proto::StickerMetadata& _internal_recentstickers(int index) const;
  ::proto::StickerMetadata* _internal_add_recentstickers();
  public:
  const ::proto::StickerMetadata& recentstickers(int index) const;
  ::proto::StickerMetadata* add_recentstickers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >&
      recentstickers() const;

  // repeated .proto.PastParticipants pastParticipants = 12;
  int pastparticipants_size() const;
  private:
  int _internal_pastparticipants_size() const;
  public:
  void clear_pastparticipants();
  ::proto::PastParticipants* mutable_pastparticipants(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >*
      mutable_pastparticipants();
  private:
  const ::proto::PastParticipants& _internal_pastparticipants(int index) const;
  ::proto::PastParticipants* _internal_add_pastparticipants();
  public:
  const ::proto::PastParticipants& pastparticipants(int index) const;
  ::proto::PastParticipants* add_pastparticipants();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >&
      pastparticipants() const;

  // optional bytes threadIdUserSecret = 9;
  bool has_threadidusersecret() const;
  private:
  bool _internal_has_threadidusersecret() const;
  public:
  void clear_threadidusersecret();
  const std::string& threadidusersecret() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_threadidusersecret(ArgT0&& arg0, ArgT... args);
  std::string* mutable_threadidusersecret();
  PROTOBUF_NODISCARD std::string* release_threadidusersecret();
  void set_allocated_threadidusersecret(std::string* threadidusersecret);
  private:
  const std::string& _internal_threadidusersecret() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_threadidusersecret(const std::string& value);
  std::string* _internal_mutable_threadidusersecret();
  public:

  // optional .proto.GlobalSettings globalSettings = 8;
  bool has_globalsettings() const;
  private:
  bool _internal_has_globalsettings() const;
  public:
  void clear_globalsettings();
  const ::proto::GlobalSettings& globalsettings() const;
  PROTOBUF_NODISCARD ::proto::GlobalSettings* release_globalsettings();
  ::proto::GlobalSettings* mutable_globalsettings();
  void set_allocated_globalsettings(::proto::GlobalSettings* globalsettings);
  private:
  const ::proto::GlobalSettings& _internal_globalsettings() const;
  ::proto::GlobalSettings* _internal_mutable_globalsettings();
  public:
  void unsafe_arena_set_allocated_globalsettings(
      ::proto::GlobalSettings* globalsettings);
  ::proto::GlobalSettings* unsafe_arena_release_globalsettings();

  // required .proto.HistorySync.HistorySyncType syncType = 1;
  bool has_synctype() const;
  private:
  bool _internal_has_synctype() const;
  public:
  void clear_synctype();
  ::proto::HistorySync_HistorySyncType synctype() const;
  void set_synctype(::proto::HistorySync_HistorySyncType value);
  private:
  ::proto::HistorySync_HistorySyncType _internal_synctype() const;
  void _internal_set_synctype(::proto::HistorySync_HistorySyncType value);
  public:

  // optional uint32 chunkOrder = 5;
  bool has_chunkorder() const;
  private:
  bool _internal_has_chunkorder() const;
  public:
  void clear_chunkorder();
  uint32_t chunkorder() const;
  void set_chunkorder(uint32_t value);
  private:
  uint32_t _internal_chunkorder() const;
  void _internal_set_chunkorder(uint32_t value);
  public:

  // optional uint32 progress = 6;
  bool has_progress() const;
  private:
  bool _internal_has_progress() const;
  public:
  void clear_progress();
  uint32_t progress() const;
  void set_progress(uint32_t value);
  private:
  uint32_t _internal_progress() const;
  void _internal_set_progress(uint32_t value);
  public:

  // optional uint32 threadDsTimeframeOffset = 10;
  bool has_threaddstimeframeoffset() const;
  private:
  bool _internal_has_threaddstimeframeoffset() const;
  public:
  void clear_threaddstimeframeoffset();
  uint32_t threaddstimeframeoffset() const;
  void set_threaddstimeframeoffset(uint32_t value);
  private:
  uint32_t _internal_threaddstimeframeoffset() const;
  void _internal_set_threaddstimeframeoffset(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.HistorySync)
 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< ::proto::Conversation > conversations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo > statusv3messages_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname > pushnames_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata > recentstickers_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants > pastparticipants_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr threadidusersecret_;
    ::proto::GlobalSettings* globalsettings_;
    int synctype_;
    uint32_t chunkorder_;
    uint32_t progress_;
    uint32_t threaddstimeframeoffset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HistorySyncMsg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HistorySyncMsg>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HistorySyncMsg& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HistorySyncMsg& from) {
    HistorySyncMsg::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kMessageFieldNumber = 1,
    kMsgOrderIdFieldNumber = 2,
  };
  // optional .proto.WebMessageInfo message = 1;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const ::proto::WebMessageInfo& message() const;
  PROTOBUF_NODISCARD ::proto::WebMessageInfo* release_message();
  ::proto::WebMessageInfo* mutable_message();
  void set_allocated_message(::proto::WebMessageInfo* message);
  private:
  const ::proto::WebMessageInfo& _internal_message() const;
  ::proto::WebMessageInfo* _internal_mutable_message();
  public:
  void unsafe_arena_set_allocated_message(
      ::proto::WebMessageInfo* message);
  ::proto::WebMessageInfo* unsafe_arena_release_message();

  // optional uint64 msgOrderId = 2;
  bool has_msgorderid() const;
  private:
  bool _internal_has_msgorderid() const;
  public:
  void clear_msgorderid();
  uint64_t msgorderid() const;
  void set_msgorderid(uint64_t value);
  private:
  uint64_t _internal_msgorderid() const;
  void _internal_set_msgorderid(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.HistorySyncMsg)
 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_;
    ::proto::WebMessageInfo* message_;
    uint64_t msgorderid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HydratedTemplateButton_HydratedCallButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedCallButton) */ {
 public:
  inline HydratedTemplateButton_HydratedCallButton() : HydratedTemplateButton_HydratedCallButton(nullptr) {}
  ~HydratedTemplateButton_HydratedCallButton() override;
  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedCallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HydratedTemplateButton_HydratedCallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HydratedTemplateButton_HydratedCallButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HydratedTemplateButton_HydratedCallButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HydratedTemplateButton_HydratedCallButton& from) {
    HydratedTemplateButton_HydratedCallButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDisplayTextFieldNumber = 1,
    kPhoneNumberFieldNumber = 2,
  };
  // optional string displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const std::string& displaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_displaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_displaytext();
  PROTOBUF_NODISCARD std::string* release_displaytext();
  void set_allocated_displaytext(std::string* displaytext);
  private:
  const std::string& _internal_displaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
  std::string* _internal_mutable_displaytext();
  public:

  // optional string phoneNumber = 2;
  bool has_phonenumber() const;
  private:
  bool _internal_has_phonenumber() const;
  public:
  void clear_phonenumber();
  const std::string& phonenumber() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_phonenumber(ArgT0&& arg0, ArgT... args);
  std::string* mutable_phonenumber();
  PROTOBUF_NODISCARD std::string* release_phonenumber();
  void set_allocated_phonenumber(std::string* phonenumber);
  private:
  const std::string& _internal_phonenumber() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phonenumber(const std::string& value);
  std::string* _internal_mutable_phonenumber();
  public:

  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedCallButton)
 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 displaytext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phonenumber_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HydratedTemplateButton_HydratedQuickReplyButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedQuickReplyButton) */ {
 public:
  inline HydratedTemplateButton_HydratedQuickReplyButton() : HydratedTemplateButton_HydratedQuickReplyButton(nullptr) {}
  ~HydratedTemplateButton_HydratedQuickReplyButton() override;
  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedQuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HydratedTemplateButton_HydratedQuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HydratedTemplateButton_HydratedQuickReplyButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HydratedTemplateButton_HydratedQuickReplyButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HydratedTemplateButton_HydratedQuickReplyButton& from) {
    HydratedTemplateButton_HydratedQuickReplyButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDisplayTextFieldNumber = 1,
    kIdFieldNumber = 2,
  };
  // optional string displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const std::string& displaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_displaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_displaytext();
  PROTOBUF_NODISCARD std::string* release_displaytext();
  void set_allocated_displaytext(std::string* displaytext);
  private:
  const std::string& _internal_displaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
  std::string* _internal_mutable_displaytext();
  public:

  // optional string id = 2;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedQuickReplyButton)
 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 displaytext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class HydratedTemplateButton_HydratedURLButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.HydratedTemplateButton.HydratedURLButton) */ {
 public:
  inline HydratedTemplateButton_HydratedURLButton() : HydratedTemplateButton_HydratedURLButton(nullptr) {}
  ~HydratedTemplateButton_HydratedURLButton() override;
  explicit PROTOBUF_CONSTEXPR HydratedTemplateButton_HydratedURLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  HydratedTemplateButton_HydratedURLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HydratedTemplateButton_HydratedURLButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HydratedTemplateButton_HydratedURLButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HydratedTemplateButton_HydratedURLButton& from) {
    HydratedTemplateButton_HydratedURLButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDisplayTextFieldNumber = 1,
    kUrlFieldNumber = 2,
  };
  // optional string displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const std::string& displaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_displaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_displaytext();
  PROTOBUF_NODISCARD std::string* release_displaytext();
  void set_allocated_displaytext(std::string* displaytext);
  private:
  const std::string& _internal_displaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
  std::string* _internal_mutable_displaytext();
  public:

  // optional string url = 2;
  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:

  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton.HydratedURLButton)
 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 displaytext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const HydratedTemplateButton& default_instance() {
    return *internal_default_instance();
  }
  enum HydratedButtonCase {
    kQuickReplyButton = 1,
    kUrlButton = 2,
    kCallButton = 3,
    HYDRATEDBUTTON_NOT_SET = 0,
  };

  static inline const HydratedTemplateButton* internal_default_instance() {
    return reinterpret_cast<const HydratedTemplateButton*>(
               &_HydratedTemplateButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

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

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

  HydratedTemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<HydratedTemplateButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const HydratedTemplateButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const HydratedTemplateButton& from) {
    HydratedTemplateButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef HydratedTemplateButton_HydratedCallButton HydratedCallButton;
  typedef HydratedTemplateButton_HydratedQuickReplyButton HydratedQuickReplyButton;
  typedef HydratedTemplateButton_HydratedURLButton HydratedURLButton;

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

  enum : int {
    kIndexFieldNumber = 4,
    kQuickReplyButtonFieldNumber = 1,
    kUrlButtonFieldNumber = 2,
    kCallButtonFieldNumber = 3,
  };
  // optional uint32 index = 4;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:

  // .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
  bool has_quickreplybutton() const;
  private:
  bool _internal_has_quickreplybutton() const;
  public:
  void clear_quickreplybutton();
  const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& quickreplybutton() const;
  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedQuickReplyButton* release_quickreplybutton();
  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* mutable_quickreplybutton();
  void set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton);
  private:
  const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& _internal_quickreplybutton() const;
  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _internal_mutable_quickreplybutton();
  public:
  void unsafe_arena_set_allocated_quickreplybutton(
      ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton);
  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* unsafe_arena_release_quickreplybutton();

  // .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
  bool has_urlbutton() const;
  private:
  bool _internal_has_urlbutton() const;
  public:
  void clear_urlbutton();
  const ::proto::HydratedTemplateButton_HydratedURLButton& urlbutton() const;
  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedURLButton* release_urlbutton();
  ::proto::HydratedTemplateButton_HydratedURLButton* mutable_urlbutton();
  void set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton);
  private:
  const ::proto::HydratedTemplateButton_HydratedURLButton& _internal_urlbutton() const;
  ::proto::HydratedTemplateButton_HydratedURLButton* _internal_mutable_urlbutton();
  public:
  void unsafe_arena_set_allocated_urlbutton(
      ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton);
  ::proto::HydratedTemplateButton_HydratedURLButton* unsafe_arena_release_urlbutton();

  // .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
  bool has_callbutton() const;
  private:
  bool _internal_has_callbutton() const;
  public:
  void clear_callbutton();
  const ::proto::HydratedTemplateButton_HydratedCallButton& callbutton() const;
  PROTOBUF_NODISCARD ::proto::HydratedTemplateButton_HydratedCallButton* release_callbutton();
  ::proto::HydratedTemplateButton_HydratedCallButton* mutable_callbutton();
  void set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton);
  private:
  const ::proto::HydratedTemplateButton_HydratedCallButton& _internal_callbutton() const;
  ::proto::HydratedTemplateButton_HydratedCallButton* _internal_mutable_callbutton();
  public:
  void unsafe_arena_set_allocated_callbutton(
      ::proto::HydratedTemplateButton_HydratedCallButton* callbutton);
  ::proto::HydratedTemplateButton_HydratedCallButton* unsafe_arena_release_callbutton();

  void clear_hydratedButton();
  HydratedButtonCase hydratedButton_case() const;
  // @@protoc_insertion_point(class_scope:proto.HydratedTemplateButton)
 private:
  class _Internal;
  void set_has_quickreplybutton();
  void set_has_urlbutton();
  void set_has_callbutton();

  inline bool has_hydratedButton() const;
  inline void clear_has_hydratedButton();

  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_;
    uint32_t index_;
    union HydratedButtonUnion {
      constexpr HydratedButtonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton_;
      ::proto::HydratedTemplateButton_HydratedURLButton* urlbutton_;
      ::proto::HydratedTemplateButton_HydratedCallButton* callbutton_;
    } hydratedButton_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  IdentityKeyPairStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IdentityKeyPairStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IdentityKeyPairStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const IdentityKeyPairStructure& from) {
    IdentityKeyPairStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kPublicKeyFieldNumber = 1,
    kPrivateKeyFieldNumber = 2,
  };
  // optional 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:

  // optional 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:proto.IdentityKeyPairStructure)
 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 publickey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InteractiveAnnotation& default_instance() {
    return *internal_default_instance();
  }
  enum ActionCase {
    kLocation = 2,
    ACTION_NOT_SET = 0,
  };

  static inline const InteractiveAnnotation* internal_default_instance() {
    return reinterpret_cast<const InteractiveAnnotation*>(
               &_InteractiveAnnotation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

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

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

  InteractiveAnnotation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InteractiveAnnotation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InteractiveAnnotation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const InteractiveAnnotation& from) {
    InteractiveAnnotation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kPolygonVerticesFieldNumber = 1,
    kLocationFieldNumber = 2,
  };
  // repeated .proto.Point polygonVertices = 1;
  int polygonvertices_size() const;
  private:
  int _internal_polygonvertices_size() const;
  public:
  void clear_polygonvertices();
  ::proto::Point* mutable_polygonvertices(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >*
      mutable_polygonvertices();
  private:
  const ::proto::Point& _internal_polygonvertices(int index) const;
  ::proto::Point* _internal_add_polygonvertices();
  public:
  const ::proto::Point& polygonvertices(int index) const;
  ::proto::Point* add_polygonvertices();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >&
      polygonvertices() const;

  // .proto.Location location = 2;
  bool has_location() const;
  private:
  bool _internal_has_location() const;
  public:
  void clear_location();
  const ::proto::Location& location() const;
  PROTOBUF_NODISCARD ::proto::Location* release_location();
  ::proto::Location* mutable_location();
  void set_allocated_location(::proto::Location* location);
  private:
  const ::proto::Location& _internal_location() const;
  ::proto::Location* _internal_mutable_location();
  public:
  void unsafe_arena_set_allocated_location(
      ::proto::Location* location);
  ::proto::Location* unsafe_arena_release_location();

  void clear_action();
  ActionCase action_case() const;
  // @@protoc_insertion_point(class_scope:proto.InteractiveAnnotation)
 private:
  class _Internal;
  void set_has_location();

  inline bool has_action() const;
  inline void clear_has_action();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point > polygonvertices_;
    union ActionUnion {
      constexpr ActionUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Location* location_;
    } action_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  KeepInChat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<KeepInChat>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const KeepInChat& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const KeepInChat& from) {
    KeepInChat::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDeviceJidFieldNumber = 4,
    kKeyFieldNumber = 3,
    kServerTimestampFieldNumber = 2,
    kKeepTypeFieldNumber = 1,
  };
  // optional string deviceJid = 4;
  bool has_devicejid() const;
  private:
  bool _internal_has_devicejid() const;
  public:
  void clear_devicejid();
  const std::string& devicejid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_devicejid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_devicejid();
  PROTOBUF_NODISCARD std::string* release_devicejid();
  void set_allocated_devicejid(std::string* devicejid);
  private:
  const std::string& _internal_devicejid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_devicejid(const std::string& value);
  std::string* _internal_mutable_devicejid();
  public:

  // optional .proto.MessageKey key = 3;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional int64 serverTimestamp = 2;
  bool has_servertimestamp() const;
  private:
  bool _internal_has_servertimestamp() const;
  public:
  void clear_servertimestamp();
  int64_t servertimestamp() const;
  void set_servertimestamp(int64_t value);
  private:
  int64_t _internal_servertimestamp() const;
  void _internal_set_servertimestamp(int64_t value);
  public:

  // optional .proto.KeepType keepType = 1;
  bool has_keeptype() const;
  private:
  bool _internal_has_keeptype() const;
  public:
  void clear_keeptype();
  ::proto::KeepType keeptype() const;
  void set_keeptype(::proto::KeepType value);
  private:
  ::proto::KeepType _internal_keeptype() const;
  void _internal_set_keeptype(::proto::KeepType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.KeepInChat)
 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 devicejid_;
    ::proto::MessageKey* key_;
    int64_t servertimestamp_;
    int keeptype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  KeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<KeyId>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const KeyId& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const KeyId& from) {
    KeyId::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kIdFieldNumber = 1,
  };
  // optional bytes id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // @@protoc_insertion_point(class_scope:proto.KeyId)
 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 id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  LocalizedName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LocalizedName>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LocalizedName& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const LocalizedName& from) {
    LocalizedName::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kLgFieldNumber = 1,
    kLcFieldNumber = 2,
    kVerifiedNameFieldNumber = 3,
  };
  // optional string lg = 1;
  bool has_lg() const;
  private:
  bool _internal_has_lg() const;
  public:
  void clear_lg();
  const std::string& lg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lg();
  PROTOBUF_NODISCARD std::string* release_lg();
  void set_allocated_lg(std::string* lg);
  private:
  const std::string& _internal_lg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lg(const std::string& value);
  std::string* _internal_mutable_lg();
  public:

  // optional string lc = 2;
  bool has_lc() const;
  private:
  bool _internal_has_lc() const;
  public:
  void clear_lc();
  const std::string& lc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_lc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_lc();
  PROTOBUF_NODISCARD std::string* release_lc();
  void set_allocated_lc(std::string* lc);
  private:
  const std::string& _internal_lc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_lc(const std::string& value);
  std::string* _internal_mutable_lc();
  public:

  // optional string verifiedName = 3;
  bool has_verifiedname() const;
  private:
  bool _internal_has_verifiedname() const;
  public:
  void clear_verifiedname();
  const std::string& verifiedname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_verifiedname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_verifiedname();
  PROTOBUF_NODISCARD std::string* release_verifiedname();
  void set_allocated_verifiedname(std::string* verifiedname);
  private:
  const std::string& _internal_verifiedname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value);
  std::string* _internal_mutable_verifiedname();
  public:

  // @@protoc_insertion_point(class_scope:proto.LocalizedName)
 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 lg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lc_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Location* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Location>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Location& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Location& from) {
    Location::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kNameFieldNumber = 3,
    kDegreesLatitudeFieldNumber = 1,
    kDegreesLongitudeFieldNumber = 2,
  };
  // optional 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:

  // optional double degreesLatitude = 1;
  bool has_degreeslatitude() const;
  private:
  bool _internal_has_degreeslatitude() const;
  public:
  void clear_degreeslatitude();
  double degreeslatitude() const;
  void set_degreeslatitude(double value);
  private:
  double _internal_degreeslatitude() const;
  void _internal_set_degreeslatitude(double value);
  public:

  // optional double degreesLongitude = 2;
  bool has_degreeslongitude() const;
  private:
  bool _internal_has_degreeslongitude() const;
  public:
  void clear_degreeslongitude();
  double degreeslongitude() const;
  void set_degreeslongitude(double value);
  private:
  double _internal_degreeslongitude() const;
  void _internal_set_degreeslongitude(double value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Location)
 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 name_;
    double degreeslatitude_;
    double degreeslongitude_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MediaData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MediaData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MediaData& from) {
    MediaData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kLocalPathFieldNumber = 1,
  };
  // optional string localPath = 1;
  bool has_localpath() const;
  private:
  bool _internal_has_localpath() const;
  public:
  void clear_localpath();
  const std::string& localpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localpath();
  PROTOBUF_NODISCARD std::string* release_localpath();
  void set_allocated_localpath(std::string* localpath);
  private:
  const std::string& _internal_localpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localpath(const std::string& value);
  std::string* _internal_mutable_localpath();
  public:

  // @@protoc_insertion_point(class_scope:proto.MediaData)
 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 localpath_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  MediaRetryNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MediaRetryNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MediaRetryNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MediaRetryNotification& from) {
    MediaRetryNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

  typedef MediaRetryNotification_ResultType ResultType;
  static constexpr ResultType GENERAL_ERROR =
    MediaRetryNotification_ResultType_GENERAL_ERROR;
  static constexpr ResultType SUCCESS =
    MediaRetryNotification_ResultType_SUCCESS;
  static constexpr ResultType NOT_FOUND =
    MediaRetryNotification_ResultType_NOT_FOUND;
  static constexpr ResultType DECRYPTION_ERROR =
    MediaRetryNotification_ResultType_DECRYPTION_ERROR;
  static inline bool ResultType_IsValid(int value) {
    return MediaRetryNotification_ResultType_IsValid(value);
  }
  static constexpr ResultType ResultType_MIN =
    MediaRetryNotification_ResultType_ResultType_MIN;
  static constexpr ResultType ResultType_MAX =
    MediaRetryNotification_ResultType_ResultType_MAX;
  static constexpr int ResultType_ARRAYSIZE =
    MediaRetryNotification_ResultType_ResultType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ResultType_descriptor() {
    return MediaRetryNotification_ResultType_descriptor();
  }
  template<typename T>
  static inline const std::string& ResultType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ResultType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ResultType_Name.");
    return MediaRetryNotification_ResultType_Name(enum_t_value);
  }
  static inline bool ResultType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ResultType* value) {
    return MediaRetryNotification_ResultType_Parse(name, value);
  }

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

  enum : int {
    kStanzaIdFieldNumber = 1,
    kDirectPathFieldNumber = 2,
    kResultFieldNumber = 3,
  };
  // optional string stanzaId = 1;
  bool has_stanzaid() const;
  private:
  bool _internal_has_stanzaid() const;
  public:
  void clear_stanzaid();
  const std::string& stanzaid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stanzaid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stanzaid();
  PROTOBUF_NODISCARD std::string* release_stanzaid();
  void set_allocated_stanzaid(std::string* stanzaid);
  private:
  const std::string& _internal_stanzaid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
  std::string* _internal_mutable_stanzaid();
  public:

  // optional string directPath = 2;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional .proto.MediaRetryNotification.ResultType result = 3;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  ::proto::MediaRetryNotification_ResultType result() const;
  void set_result(::proto::MediaRetryNotification_ResultType value);
  private:
  ::proto::MediaRetryNotification_ResultType _internal_result() const;
  void _internal_set_result(::proto::MediaRetryNotification_ResultType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.MediaRetryNotification)
 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 stanzaid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    int result_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AppStateFatalExceptionNotification final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateFatalExceptionNotification) */ {
 public:
  inline Message_AppStateFatalExceptionNotification() : Message_AppStateFatalExceptionNotification(nullptr) {}
  ~Message_AppStateFatalExceptionNotification() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateFatalExceptionNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateFatalExceptionNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateFatalExceptionNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateFatalExceptionNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateFatalExceptionNotification& from) {
    Message_AppStateFatalExceptionNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kCollectionNamesFieldNumber = 1,
    kTimestampFieldNumber = 2,
  };
  // repeated string collectionNames = 1;
  int collectionnames_size() const;
  private:
  int _internal_collectionnames_size() const;
  public:
  void clear_collectionnames();
  const std::string& collectionnames(int index) const;
  std::string* mutable_collectionnames(int index);
  void set_collectionnames(int index, const std::string& value);
  void set_collectionnames(int index, std::string&& value);
  void set_collectionnames(int index, const char* value);
  void set_collectionnames(int index, const char* value, size_t size);
  std::string* add_collectionnames();
  void add_collectionnames(const std::string& value);
  void add_collectionnames(std::string&& value);
  void add_collectionnames(const char* value);
  void add_collectionnames(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& collectionnames() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_collectionnames();
  private:
  const std::string& _internal_collectionnames(int index) const;
  std::string* _internal_add_collectionnames();
  public:

  // optional int64 timestamp = 2;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateFatalExceptionNotification)
 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> collectionnames_;
    int64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AppStateSyncKeyData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyData) */ {
 public:
  inline Message_AppStateSyncKeyData() : Message_AppStateSyncKeyData(nullptr) {}
  ~Message_AppStateSyncKeyData() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKeyData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKeyData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKeyData& from) {
    Message_AppStateSyncKeyData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyDataFieldNumber = 1,
    kFingerprintFieldNumber = 2,
    kTimestampFieldNumber = 3,
  };
  // optional bytes keyData = 1;
  bool has_keydata() const;
  private:
  bool _internal_has_keydata() const;
  public:
  void clear_keydata();
  const std::string& keydata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_keydata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_keydata();
  PROTOBUF_NODISCARD std::string* release_keydata();
  void set_allocated_keydata(std::string* keydata);
  private:
  const std::string& _internal_keydata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_keydata(const std::string& value);
  std::string* _internal_mutable_keydata();
  public:

  // optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
  bool has_fingerprint() const;
  private:
  bool _internal_has_fingerprint() const;
  public:
  void clear_fingerprint();
  const ::proto::Message_AppStateSyncKeyFingerprint& fingerprint() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyFingerprint* release_fingerprint();
  ::proto::Message_AppStateSyncKeyFingerprint* mutable_fingerprint();
  void set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint);
  private:
  const ::proto::Message_AppStateSyncKeyFingerprint& _internal_fingerprint() const;
  ::proto::Message_AppStateSyncKeyFingerprint* _internal_mutable_fingerprint();
  public:
  void unsafe_arena_set_allocated_fingerprint(
      ::proto::Message_AppStateSyncKeyFingerprint* fingerprint);
  ::proto::Message_AppStateSyncKeyFingerprint* unsafe_arena_release_fingerprint();

  // optional int64 timestamp = 3;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyData)
 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 keydata_;
    ::proto::Message_AppStateSyncKeyFingerprint* fingerprint_;
    int64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AppStateSyncKeyFingerprint final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyFingerprint) */ {
 public:
  inline Message_AppStateSyncKeyFingerprint() : Message_AppStateSyncKeyFingerprint(nullptr) {}
  ~Message_AppStateSyncKeyFingerprint() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyFingerprint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKeyFingerprint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKeyFingerprint>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKeyFingerprint& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKeyFingerprint& from) {
    Message_AppStateSyncKeyFingerprint::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kDeviceIndexesFieldNumber = 3,
    kRawIdFieldNumber = 1,
    kCurrentIndexFieldNumber = 2,
  };
  // repeated uint32 deviceIndexes = 3 [packed = true];
  int deviceindexes_size() const;
  private:
  int _internal_deviceindexes_size() const;
  public:
  void clear_deviceindexes();
  private:
  uint32_t _internal_deviceindexes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_deviceindexes() const;
  void _internal_add_deviceindexes(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_deviceindexes();
  public:
  uint32_t deviceindexes(int index) const;
  void set_deviceindexes(int index, uint32_t value);
  void add_deviceindexes(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      deviceindexes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_deviceindexes();

  // optional uint32 rawId = 1;
  bool has_rawid() const;
  private:
  bool _internal_has_rawid() const;
  public:
  void clear_rawid();
  uint32_t rawid() const;
  void set_rawid(uint32_t value);
  private:
  uint32_t _internal_rawid() const;
  void _internal_set_rawid(uint32_t value);
  public:

  // optional uint32 currentIndex = 2;
  bool has_currentindex() const;
  private:
  bool _internal_has_currentindex() const;
  public:
  void clear_currentindex();
  uint32_t currentindex() const;
  void set_currentindex(uint32_t value);
  private:
  uint32_t _internal_currentindex() const;
  void _internal_set_currentindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyFingerprint)
 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< uint32_t > deviceindexes_;
    mutable std::atomic<int> _deviceindexes_cached_byte_size_;
    uint32_t rawid_;
    uint32_t currentindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AppStateSyncKeyId final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyId) */ {
 public:
  inline Message_AppStateSyncKeyId() : Message_AppStateSyncKeyId(nullptr) {}
  ~Message_AppStateSyncKeyId() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKeyId>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKeyId& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKeyId& from) {
    Message_AppStateSyncKeyId::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyIdFieldNumber = 1,
  };
  // optional bytes keyId = 1;
  bool has_keyid() const;
  private:
  bool _internal_has_keyid() const;
  public:
  void clear_keyid();
  const std::string& keyid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_keyid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_keyid();
  PROTOBUF_NODISCARD std::string* release_keyid();
  void set_allocated_keyid(std::string* keyid);
  private:
  const std::string& _internal_keyid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_keyid(const std::string& value);
  std::string* _internal_mutable_keyid();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyId)
 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 keyid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AppStateSyncKeyRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyRequest) */ {
 public:
  inline Message_AppStateSyncKeyRequest() : Message_AppStateSyncKeyRequest(nullptr) {}
  ~Message_AppStateSyncKeyRequest() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKeyRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKeyRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKeyRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKeyRequest& from) {
    Message_AppStateSyncKeyRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyIdsFieldNumber = 1,
  };
  // repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
  int keyids_size() const;
  private:
  int _internal_keyids_size() const;
  public:
  void clear_keyids();
  ::proto::Message_AppStateSyncKeyId* mutable_keyids(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >*
      mutable_keyids();
  private:
  const ::proto::Message_AppStateSyncKeyId& _internal_keyids(int index) const;
  ::proto::Message_AppStateSyncKeyId* _internal_add_keyids();
  public:
  const ::proto::Message_AppStateSyncKeyId& keyids(int index) const;
  ::proto::Message_AppStateSyncKeyId* add_keyids();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >&
      keyids() const;

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyRequest)
 private:
  class _Internal;

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

class Message_AppStateSyncKeyShare final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKeyShare) */ {
 public:
  inline Message_AppStateSyncKeyShare() : Message_AppStateSyncKeyShare(nullptr) {}
  ~Message_AppStateSyncKeyShare() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKeyShare(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKeyShare* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKeyShare>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKeyShare& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKeyShare& from) {
    Message_AppStateSyncKeyShare::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeysFieldNumber = 1,
  };
  // repeated .proto.Message.AppStateSyncKey keys = 1;
  int keys_size() const;
  private:
  int _internal_keys_size() const;
  public:
  void clear_keys();
  ::proto::Message_AppStateSyncKey* mutable_keys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >*
      mutable_keys();
  private:
  const ::proto::Message_AppStateSyncKey& _internal_keys(int index) const;
  ::proto::Message_AppStateSyncKey* _internal_add_keys();
  public:
  const ::proto::Message_AppStateSyncKey& keys(int index) const;
  ::proto::Message_AppStateSyncKey* add_keys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >&
      keys() const;

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKeyShare)
 private:
  class _Internal;

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

class Message_AppStateSyncKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AppStateSyncKey) */ {
 public:
  inline Message_AppStateSyncKey() : Message_AppStateSyncKey(nullptr) {}
  ~Message_AppStateSyncKey() override;
  explicit PROTOBUF_CONSTEXPR Message_AppStateSyncKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AppStateSyncKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AppStateSyncKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AppStateSyncKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AppStateSyncKey& from) {
    Message_AppStateSyncKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kKeyIdFieldNumber = 1,
    kKeyDataFieldNumber = 2,
  };
  // optional .proto.Message.AppStateSyncKeyId keyId = 1;
  bool has_keyid() const;
  private:
  bool _internal_has_keyid() const;
  public:
  void clear_keyid();
  const ::proto::Message_AppStateSyncKeyId& keyid() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyId* release_keyid();
  ::proto::Message_AppStateSyncKeyId* mutable_keyid();
  void set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid);
  private:
  const ::proto::Message_AppStateSyncKeyId& _internal_keyid() const;
  ::proto::Message_AppStateSyncKeyId* _internal_mutable_keyid();
  public:
  void unsafe_arena_set_allocated_keyid(
      ::proto::Message_AppStateSyncKeyId* keyid);
  ::proto::Message_AppStateSyncKeyId* unsafe_arena_release_keyid();

  // optional .proto.Message.AppStateSyncKeyData keyData = 2;
  bool has_keydata() const;
  private:
  bool _internal_has_keydata() const;
  public:
  void clear_keydata();
  const ::proto::Message_AppStateSyncKeyData& keydata() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyData* release_keydata();
  ::proto::Message_AppStateSyncKeyData* mutable_keydata();
  void set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata);
  private:
  const ::proto::Message_AppStateSyncKeyData& _internal_keydata() const;
  ::proto::Message_AppStateSyncKeyData* _internal_mutable_keydata();
  public:
  void unsafe_arena_set_allocated_keydata(
      ::proto::Message_AppStateSyncKeyData* keydata);
  ::proto::Message_AppStateSyncKeyData* unsafe_arena_release_keydata();

  // @@protoc_insertion_point(class_scope:proto.Message.AppStateSyncKey)
 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_;
    ::proto::Message_AppStateSyncKeyId* keyid_;
    ::proto::Message_AppStateSyncKeyData* keydata_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_AudioMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.AudioMessage) */ {
 public:
  inline Message_AudioMessage() : Message_AudioMessage(nullptr) {}
  ~Message_AudioMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_AudioMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_AudioMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_AudioMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_AudioMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_AudioMessage& from) {
    Message_AudioMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

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

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

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

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

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

  enum : int {
    kUrlFieldNumber = 1,
    kMimetypeFieldNumber = 2,
    kFileSha256FieldNumber = 3,
    kMediaKeyFieldNumber = 7,
    kFileEncSha256FieldNumber = 8,
    kDirectPathFieldNumber = 9,
    kStreamingSidecarFieldNumber = 18,
    kWaveformFieldNumber = 19,
    kContextInfoFieldNumber = 17,
    kFileLengthFieldNumber = 4,
    kSecondsFieldNumber = 5,
    kPttFieldNumber = 6,
    kMediaKeyTimestampFieldNumber = 10,
  };
  // optional 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 mimetype = 2;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional bytes fileSha256 = 3;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes mediaKey = 7;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional bytes fileEncSha256 = 8;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 9;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional bytes streamingSidecar = 18;
  bool has_streamingsidecar() const;
  private:
  bool _internal_has_streamingsidecar() const;
  public:
  void clear_streamingsidecar();
  const std::string& streamingsidecar() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_streamingsidecar(ArgT0&& arg0, ArgT... args);
  std::string* mutable_streamingsidecar();
  PROTOBUF_NODISCARD std::string* release_streamingsidecar();
  void set_allocated_streamingsidecar(std::string* streamingsidecar);
  private:
  const std::string& _internal_streamingsidecar() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value);
  std::string* _internal_mutable_streamingsidecar();
  public:

  // optional bytes waveform = 19;
  bool has_waveform() const;
  private:
  bool _internal_has_waveform() const;
  public:
  void clear_waveform();
  const std::string& waveform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_waveform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_waveform();
  PROTOBUF_NODISCARD std::string* release_waveform();
  void set_allocated_waveform(std::string* waveform);
  private:
  const std::string& _internal_waveform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_waveform(const std::string& value);
  std::string* _internal_mutable_waveform();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint64 fileLength = 4;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional uint32 seconds = 5;
  bool has_seconds() const;
  private:
  bool _internal_has_seconds() const;
  public:
  void clear_seconds();
  uint32_t seconds() const;
  void set_seconds(uint32_t value);
  private:
  uint32_t _internal_seconds() const;
  void _internal_set_seconds(uint32_t value);
  public:

  // optional bool ptt = 6;
  bool has_ptt() const;
  private:
  bool _internal_has_ptt() const;
  public:
  void clear_ptt();
  bool ptt() const;
  void set_ptt(bool value);
  private:
  bool _internal_ptt() const;
  void _internal_set_ptt(bool value);
  public:

  // optional int64 mediaKeyTimestamp = 10;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.AudioMessage)
 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 mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr waveform_;
    ::proto::ContextInfo* contextinfo_;
    uint64_t filelength_;
    uint32_t seconds_;
    bool ptt_;
    int64_t mediakeytimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ButtonsMessage_Button_ButtonText final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.ButtonText) */ {
 public:
  inline Message_ButtonsMessage_Button_ButtonText() : Message_ButtonsMessage_Button_ButtonText(nullptr) {}
  ~Message_ButtonsMessage_Button_ButtonText() override;
  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_ButtonsMessage_Button_ButtonText* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ButtonsMessage_Button_ButtonText>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ButtonsMessage_Button_ButtonText& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ButtonsMessage_Button_ButtonText& from) {
    Message_ButtonsMessage_Button_ButtonText::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ButtonsMessage.Button.ButtonText";
  }
  protected:
  explicit Message_ButtonsMessage_Button_ButtonText(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kDisplayTextFieldNumber = 1,
  };
  // optional string displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const std::string& displaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_displaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_displaytext();
  PROTOBUF_NODISCARD std::string* release_displaytext();
  void set_allocated_displaytext(std::string* displaytext);
  private:
  const std::string& _internal_displaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_displaytext(const std::string& value);
  std::string* _internal_mutable_displaytext();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.ButtonText)
 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 displaytext_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ButtonsMessage_Button_NativeFlowInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button.NativeFlowInfo) */ {
 public:
  inline Message_ButtonsMessage_Button_NativeFlowInfo() : Message_ButtonsMessage_Button_NativeFlowInfo(nullptr) {}
  ~Message_ButtonsMessage_Button_NativeFlowInfo() override;
  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_ButtonsMessage_Button_NativeFlowInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ButtonsMessage_Button_NativeFlowInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ButtonsMessage_Button_NativeFlowInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ButtonsMessage_Button_NativeFlowInfo& from) {
    Message_ButtonsMessage_Button_NativeFlowInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

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

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ButtonsMessage.Button.NativeFlowInfo";
  }
  protected:
  explicit Message_ButtonsMessage_Button_NativeFlowInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

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

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

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

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

  enum : int {
    kNameFieldNumber = 1,
    kParamsJsonFieldNumber = 2,
  };
  // optional string name = 1;
  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:

  // optional string paramsJson = 2;
  bool has_paramsjson() const;
  private:
  bool _internal_has_paramsjson() const;
  public:
  void clear_paramsjson();
  const std::string& paramsjson() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_paramsjson(ArgT0&& arg0, ArgT... args);
  std::string* mutable_paramsjson();
  PROTOBUF_NODISCARD std::string* release_paramsjson();
  void set_allocated_paramsjson(std::string* paramsjson);
  private:
  const std::string& _internal_paramsjson() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value);
  std::string* _internal_mutable_paramsjson();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button.NativeFlowInfo)
 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 name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ButtonsMessage_Button final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage.Button) */ {
 public:
  inline Message_ButtonsMessage_Button() : Message_ButtonsMessage_Button(nullptr) {}
  ~Message_ButtonsMessage_Button() override;
  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

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

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

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

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

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

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

  Message_ButtonsMessage_Button* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ButtonsMessage_Button>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ButtonsMessage_Button& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ButtonsMessage_Button& from) {
    Message_ButtonsMessage_Button::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

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

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ButtonsMessage_Button* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ButtonsMessage.Button";
  }
  protected:
  explicit Message_ButtonsMessage_Button(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ButtonsMessage_Button_ButtonText ButtonText;
  typedef Message_ButtonsMessage_Button_NativeFlowInfo NativeFlowInfo;

  typedef Message_ButtonsMessage_Button_Type Type;
  static constexpr Type UNKNOWN =
    Message_ButtonsMessage_Button_Type_UNKNOWN;
  static constexpr Type RESPONSE =
    Message_ButtonsMessage_Button_Type_RESPONSE;
  static constexpr Type NATIVE_FLOW =
    Message_ButtonsMessage_Button_Type_NATIVE_FLOW;
  static inline bool Type_IsValid(int value) {
    return Message_ButtonsMessage_Button_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Message_ButtonsMessage_Button_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Message_ButtonsMessage_Button_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Message_ButtonsMessage_Button_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Message_ButtonsMessage_Button_Type_descriptor();
  }
  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 Message_ButtonsMessage_Button_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Message_ButtonsMessage_Button_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kButtonIdFieldNumber = 1,
    kButtonTextFieldNumber = 2,
    kNativeFlowInfoFieldNumber = 4,
    kTypeFieldNumber = 3,
  };
  // optional string buttonId = 1;
  bool has_buttonid() const;
  private:
  bool _internal_has_buttonid() const;
  public:
  void clear_buttonid();
  const std::string& buttonid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_buttonid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_buttonid();
  PROTOBUF_NODISCARD std::string* release_buttonid();
  void set_allocated_buttonid(std::string* buttonid);
  private:
  const std::string& _internal_buttonid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonid(const std::string& value);
  std::string* _internal_mutable_buttonid();
  public:

  // optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
  bool has_buttontext() const;
  private:
  bool _internal_has_buttontext() const;
  public:
  void clear_buttontext();
  const ::proto::Message_ButtonsMessage_Button_ButtonText& buttontext() const;
  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_ButtonText* release_buttontext();
  ::proto::Message_ButtonsMessage_Button_ButtonText* mutable_buttontext();
  void set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext);
  private:
  const ::proto::Message_ButtonsMessage_Button_ButtonText& _internal_buttontext() const;
  ::proto::Message_ButtonsMessage_Button_ButtonText* _internal_mutable_buttontext();
  public:
  void unsafe_arena_set_allocated_buttontext(
      ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext);
  ::proto::Message_ButtonsMessage_Button_ButtonText* unsafe_arena_release_buttontext();

  // optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
  bool has_nativeflowinfo() const;
  private:
  bool _internal_has_nativeflowinfo() const;
  public:
  void clear_nativeflowinfo();
  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& nativeflowinfo() const;
  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* release_nativeflowinfo();
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* mutable_nativeflowinfo();
  void set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo);
  private:
  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& _internal_nativeflowinfo() const;
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _internal_mutable_nativeflowinfo();
  public:
  void unsafe_arena_set_allocated_nativeflowinfo(
      ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo);
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* unsafe_arena_release_nativeflowinfo();

  // optional .proto.Message.ButtonsMessage.Button.Type type = 3;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::proto::Message_ButtonsMessage_Button_Type type() const;
  void set_type(::proto::Message_ButtonsMessage_Button_Type value);
  private:
  ::proto::Message_ButtonsMessage_Button_Type _internal_type() const;
  void _internal_set_type(::proto::Message_ButtonsMessage_Button_Type value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage.Button)
 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 buttonid_;
    ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext_;
    ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ButtonsMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsMessage) */ {
 public:
  inline Message_ButtonsMessage() : Message_ButtonsMessage(nullptr) {}
  ~Message_ButtonsMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ButtonsMessage(const Message_ButtonsMessage& from);
  Message_ButtonsMessage(Message_ButtonsMessage&& from) noexcept
    : Message_ButtonsMessage() {
    *this = ::std::move(from);
  }

  inline Message_ButtonsMessage& operator=(const Message_ButtonsMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ButtonsMessage& operator=(Message_ButtonsMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ButtonsMessage& default_instance() {
    return *internal_default_instance();
  }
  enum HeaderCase {
    kText = 1,
    kDocumentMessage = 2,
    kImageMessage = 3,
    kVideoMessage = 4,
    kLocationMessage = 5,
    HEADER_NOT_SET = 0,
  };

  static inline const Message_ButtonsMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ButtonsMessage*>(
               &_Message_ButtonsMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  friend void swap(Message_ButtonsMessage& a, Message_ButtonsMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ButtonsMessage* 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(Message_ButtonsMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ButtonsMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ButtonsMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ButtonsMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ButtonsMessage& from) {
    Message_ButtonsMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ButtonsMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ButtonsMessage";
  }
  protected:
  explicit Message_ButtonsMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ButtonsMessage_Button Button;

  typedef Message_ButtonsMessage_HeaderType HeaderType;
  static constexpr HeaderType UNKNOWN =
    Message_ButtonsMessage_HeaderType_UNKNOWN;
  static constexpr HeaderType EMPTY =
    Message_ButtonsMessage_HeaderType_EMPTY;
  static constexpr HeaderType TEXT =
    Message_ButtonsMessage_HeaderType_TEXT;
  static constexpr HeaderType DOCUMENT =
    Message_ButtonsMessage_HeaderType_DOCUMENT;
  static constexpr HeaderType IMAGE =
    Message_ButtonsMessage_HeaderType_IMAGE;
  static constexpr HeaderType VIDEO =
    Message_ButtonsMessage_HeaderType_VIDEO;
  static constexpr HeaderType LOCATION =
    Message_ButtonsMessage_HeaderType_LOCATION;
  static inline bool HeaderType_IsValid(int value) {
    return Message_ButtonsMessage_HeaderType_IsValid(value);
  }
  static constexpr HeaderType HeaderType_MIN =
    Message_ButtonsMessage_HeaderType_HeaderType_MIN;
  static constexpr HeaderType HeaderType_MAX =
    Message_ButtonsMessage_HeaderType_HeaderType_MAX;
  static constexpr int HeaderType_ARRAYSIZE =
    Message_ButtonsMessage_HeaderType_HeaderType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HeaderType_descriptor() {
    return Message_ButtonsMessage_HeaderType_descriptor();
  }
  template<typename T>
  static inline const std::string& HeaderType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HeaderType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HeaderType_Name.");
    return Message_ButtonsMessage_HeaderType_Name(enum_t_value);
  }
  static inline bool HeaderType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HeaderType* value) {
    return Message_ButtonsMessage_HeaderType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kButtonsFieldNumber = 9,
    kContentTextFieldNumber = 6,
    kFooterTextFieldNumber = 7,
    kContextInfoFieldNumber = 8,
    kHeaderTypeFieldNumber = 10,
    kTextFieldNumber = 1,
    kDocumentMessageFieldNumber = 2,
    kImageMessageFieldNumber = 3,
    kVideoMessageFieldNumber = 4,
    kLocationMessageFieldNumber = 5,
  };
  // repeated .proto.Message.ButtonsMessage.Button buttons = 9;
  int buttons_size() const;
  private:
  int _internal_buttons_size() const;
  public:
  void clear_buttons();
  ::proto::Message_ButtonsMessage_Button* mutable_buttons(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >*
      mutable_buttons();
  private:
  const ::proto::Message_ButtonsMessage_Button& _internal_buttons(int index) const;
  ::proto::Message_ButtonsMessage_Button* _internal_add_buttons();
  public:
  const ::proto::Message_ButtonsMessage_Button& buttons(int index) const;
  ::proto::Message_ButtonsMessage_Button* add_buttons();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >&
      buttons() const;

  // optional string contentText = 6;
  bool has_contenttext() const;
  private:
  bool _internal_has_contenttext() const;
  public:
  void clear_contenttext();
  const std::string& contenttext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_contenttext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_contenttext();
  PROTOBUF_NODISCARD std::string* release_contenttext();
  void set_allocated_contenttext(std::string* contenttext);
  private:
  const std::string& _internal_contenttext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_contenttext(const std::string& value);
  std::string* _internal_mutable_contenttext();
  public:

  // optional string footerText = 7;
  bool has_footertext() const;
  private:
  bool _internal_has_footertext() const;
  public:
  void clear_footertext();
  const std::string& footertext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_footertext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_footertext();
  PROTOBUF_NODISCARD std::string* release_footertext();
  void set_allocated_footertext(std::string* footertext);
  private:
  const std::string& _internal_footertext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value);
  std::string* _internal_mutable_footertext();
  public:

  // optional .proto.ContextInfo contextInfo = 8;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
  bool has_headertype() const;
  private:
  bool _internal_has_headertype() const;
  public:
  void clear_headertype();
  ::proto::Message_ButtonsMessage_HeaderType headertype() const;
  void set_headertype(::proto::Message_ButtonsMessage_HeaderType value);
  private:
  ::proto::Message_ButtonsMessage_HeaderType _internal_headertype() const;
  void _internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value);
  public:

  // string text = 1;
  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:

  // .proto.Message.DocumentMessage documentMessage = 2;
  bool has_documentmessage() const;
  private:
  bool _internal_has_documentmessage() const;
  public:
  void clear_documentmessage();
  const ::proto::Message_DocumentMessage& documentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
  ::proto::Message_DocumentMessage* mutable_documentmessage();
  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
  private:
  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
  public:
  void unsafe_arena_set_allocated_documentmessage(
      ::proto::Message_DocumentMessage* documentmessage);
  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();

  // .proto.Message.ImageMessage imageMessage = 3;
  bool has_imagemessage() const;
  private:
  bool _internal_has_imagemessage() const;
  public:
  void clear_imagemessage();
  const ::proto::Message_ImageMessage& imagemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
  ::proto::Message_ImageMessage* mutable_imagemessage();
  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
  private:
  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
  public:
  void unsafe_arena_set_allocated_imagemessage(
      ::proto::Message_ImageMessage* imagemessage);
  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();

  // .proto.Message.VideoMessage videoMessage = 4;
  bool has_videomessage() const;
  private:
  bool _internal_has_videomessage() const;
  public:
  void clear_videomessage();
  const ::proto::Message_VideoMessage& videomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
  ::proto::Message_VideoMessage* mutable_videomessage();
  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
  private:
  const ::proto::Message_VideoMessage& _internal_videomessage() const;
  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
  public:
  void unsafe_arena_set_allocated_videomessage(
      ::proto::Message_VideoMessage* videomessage);
  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();

  // .proto.Message.LocationMessage locationMessage = 5;
  bool has_locationmessage() const;
  private:
  bool _internal_has_locationmessage() const;
  public:
  void clear_locationmessage();
  const ::proto::Message_LocationMessage& locationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
  ::proto::Message_LocationMessage* mutable_locationmessage();
  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
  private:
  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
  public:
  void unsafe_arena_set_allocated_locationmessage(
      ::proto::Message_LocationMessage* locationmessage);
  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();

  void clear_header();
  HeaderCase header_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsMessage)
 private:
  class _Internal;
  void set_has_text();
  void set_has_documentmessage();
  void set_has_imagemessage();
  void set_has_videomessage();
  void set_has_locationmessage();

  inline bool has_header() const;
  inline void clear_has_header();

  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< ::proto::Message_ButtonsMessage_Button > buttons_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr contenttext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_;
    ::proto::ContextInfo* contextinfo_;
    int headertype_;
    union HeaderUnion {
      constexpr HeaderUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
      ::proto::Message_DocumentMessage* documentmessage_;
      ::proto::Message_ImageMessage* imagemessage_;
      ::proto::Message_VideoMessage* videomessage_;
      ::proto::Message_LocationMessage* locationmessage_;
    } header_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ButtonsResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ButtonsResponseMessage) */ {
 public:
  inline Message_ButtonsResponseMessage() : Message_ButtonsResponseMessage(nullptr) {}
  ~Message_ButtonsResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ButtonsResponseMessage(const Message_ButtonsResponseMessage& from);
  Message_ButtonsResponseMessage(Message_ButtonsResponseMessage&& from) noexcept
    : Message_ButtonsResponseMessage() {
    *this = ::std::move(from);
  }

  inline Message_ButtonsResponseMessage& operator=(const Message_ButtonsResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ButtonsResponseMessage& operator=(Message_ButtonsResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ButtonsResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  enum ResponseCase {
    kSelectedDisplayText = 2,
    RESPONSE_NOT_SET = 0,
  };

  static inline const Message_ButtonsResponseMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ButtonsResponseMessage*>(
               &_Message_ButtonsResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  friend void swap(Message_ButtonsResponseMessage& a, Message_ButtonsResponseMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ButtonsResponseMessage* 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(Message_ButtonsResponseMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ButtonsResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ButtonsResponseMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ButtonsResponseMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ButtonsResponseMessage& from) {
    Message_ButtonsResponseMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ButtonsResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ButtonsResponseMessage";
  }
  protected:
  explicit Message_ButtonsResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ButtonsResponseMessage_Type Type;
  static constexpr Type UNKNOWN =
    Message_ButtonsResponseMessage_Type_UNKNOWN;
  static constexpr Type DISPLAY_TEXT =
    Message_ButtonsResponseMessage_Type_DISPLAY_TEXT;
  static inline bool Type_IsValid(int value) {
    return Message_ButtonsResponseMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Message_ButtonsResponseMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Message_ButtonsResponseMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Message_ButtonsResponseMessage_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Message_ButtonsResponseMessage_Type_descriptor();
  }
  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 Message_ButtonsResponseMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Message_ButtonsResponseMessage_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kSelectedButtonIdFieldNumber = 1,
    kContextInfoFieldNumber = 3,
    kTypeFieldNumber = 4,
    kSelectedDisplayTextFieldNumber = 2,
  };
  // optional string selectedButtonId = 1;
  bool has_selectedbuttonid() const;
  private:
  bool _internal_has_selectedbuttonid() const;
  public:
  void clear_selectedbuttonid();
  const std::string& selectedbuttonid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_selectedbuttonid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_selectedbuttonid();
  PROTOBUF_NODISCARD std::string* release_selectedbuttonid();
  void set_allocated_selectedbuttonid(std::string* selectedbuttonid);
  private:
  const std::string& _internal_selectedbuttonid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedbuttonid(const std::string& value);
  std::string* _internal_mutable_selectedbuttonid();
  public:

  // optional .proto.ContextInfo contextInfo = 3;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional .proto.Message.ButtonsResponseMessage.Type type = 4;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::proto::Message_ButtonsResponseMessage_Type type() const;
  void set_type(::proto::Message_ButtonsResponseMessage_Type value);
  private:
  ::proto::Message_ButtonsResponseMessage_Type _internal_type() const;
  void _internal_set_type(::proto::Message_ButtonsResponseMessage_Type value);
  public:

  // string selectedDisplayText = 2;
  bool has_selecteddisplaytext() const;
  private:
  bool _internal_has_selecteddisplaytext() const;
  public:
  void clear_selecteddisplaytext();
  const std::string& selecteddisplaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_selecteddisplaytext();
  PROTOBUF_NODISCARD std::string* release_selecteddisplaytext();
  void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext);
  private:
  const std::string& _internal_selecteddisplaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value);
  std::string* _internal_mutable_selecteddisplaytext();
  public:

  void clear_response();
  ResponseCase response_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.ButtonsResponseMessage)
 private:
  class _Internal;
  void set_has_selecteddisplaytext();

  inline bool has_response() const;
  inline void clear_has_response();

  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 selectedbuttonid_;
    ::proto::ContextInfo* contextinfo_;
    int type_;
    union ResponseUnion {
      constexpr ResponseUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_;
    } response_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_Call final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Call) */ {
 public:
  inline Message_Call() : Message_Call(nullptr) {}
  ~Message_Call() override;
  explicit PROTOBUF_CONSTEXPR Message_Call(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_Call(const Message_Call& from);
  Message_Call(Message_Call&& from) noexcept
    : Message_Call() {
    *this = ::std::move(from);
  }

  inline Message_Call& operator=(const Message_Call& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_Call& operator=(Message_Call&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_Call& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_Call* internal_default_instance() {
    return reinterpret_cast<const Message_Call*>(
               &_Message_Call_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  friend void swap(Message_Call& a, Message_Call& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_Call* 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(Message_Call* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_Call* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_Call>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_Call& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_Call& from) {
    Message_Call::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_Call* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.Call";
  }
  protected:
  explicit Message_Call(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCallKeyFieldNumber = 1,
    kConversionSourceFieldNumber = 2,
    kConversionDataFieldNumber = 3,
    kConversionDelaySecondsFieldNumber = 4,
  };
  // optional bytes callKey = 1;
  bool has_callkey() const;
  private:
  bool _internal_has_callkey() const;
  public:
  void clear_callkey();
  const std::string& callkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_callkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_callkey();
  PROTOBUF_NODISCARD std::string* release_callkey();
  void set_allocated_callkey(std::string* callkey);
  private:
  const std::string& _internal_callkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_callkey(const std::string& value);
  std::string* _internal_mutable_callkey();
  public:

  // optional string conversionSource = 2;
  bool has_conversionsource() const;
  private:
  bool _internal_has_conversionsource() const;
  public:
  void clear_conversionsource();
  const std::string& conversionsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_conversionsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_conversionsource();
  PROTOBUF_NODISCARD std::string* release_conversionsource();
  void set_allocated_conversionsource(std::string* conversionsource);
  private:
  const std::string& _internal_conversionsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversionsource(const std::string& value);
  std::string* _internal_mutable_conversionsource();
  public:

  // optional bytes conversionData = 3;
  bool has_conversiondata() const;
  private:
  bool _internal_has_conversiondata() const;
  public:
  void clear_conversiondata();
  const std::string& conversiondata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_conversiondata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_conversiondata();
  PROTOBUF_NODISCARD std::string* release_conversiondata();
  void set_allocated_conversiondata(std::string* conversiondata);
  private:
  const std::string& _internal_conversiondata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversiondata(const std::string& value);
  std::string* _internal_mutable_conversiondata();
  public:

  // optional uint32 conversionDelaySeconds = 4;
  bool has_conversiondelayseconds() const;
  private:
  bool _internal_has_conversiondelayseconds() const;
  public:
  void clear_conversiondelayseconds();
  uint32_t conversiondelayseconds() const;
  void set_conversiondelayseconds(uint32_t value);
  private:
  uint32_t _internal_conversiondelayseconds() const;
  void _internal_set_conversiondelayseconds(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.Call)
 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 callkey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversionsource_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversiondata_;
    uint32_t conversiondelayseconds_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_CancelPaymentRequestMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.CancelPaymentRequestMessage) */ {
 public:
  inline Message_CancelPaymentRequestMessage() : Message_CancelPaymentRequestMessage(nullptr) {}
  ~Message_CancelPaymentRequestMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_CancelPaymentRequestMessage(const Message_CancelPaymentRequestMessage& from);
  Message_CancelPaymentRequestMessage(Message_CancelPaymentRequestMessage&& from) noexcept
    : Message_CancelPaymentRequestMessage() {
    *this = ::std::move(from);
  }

  inline Message_CancelPaymentRequestMessage& operator=(const Message_CancelPaymentRequestMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_CancelPaymentRequestMessage& operator=(Message_CancelPaymentRequestMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_CancelPaymentRequestMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_CancelPaymentRequestMessage* internal_default_instance() {
    return reinterpret_cast<const Message_CancelPaymentRequestMessage*>(
               &_Message_CancelPaymentRequestMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  friend void swap(Message_CancelPaymentRequestMessage& a, Message_CancelPaymentRequestMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_CancelPaymentRequestMessage* 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(Message_CancelPaymentRequestMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_CancelPaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_CancelPaymentRequestMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_CancelPaymentRequestMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_CancelPaymentRequestMessage& from) {
    Message_CancelPaymentRequestMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_CancelPaymentRequestMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.CancelPaymentRequestMessage";
  }
  protected:
  explicit Message_CancelPaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
  };
  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // @@protoc_insertion_point(class_scope:proto.Message.CancelPaymentRequestMessage)
 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_;
    ::proto::MessageKey* key_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_Chat final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.Chat) */ {
 public:
  inline Message_Chat() : Message_Chat(nullptr) {}
  ~Message_Chat() override;
  explicit PROTOBUF_CONSTEXPR Message_Chat(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_Chat(const Message_Chat& from);
  Message_Chat(Message_Chat&& from) noexcept
    : Message_Chat() {
    *this = ::std::move(from);
  }

  inline Message_Chat& operator=(const Message_Chat& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_Chat& operator=(Message_Chat&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_Chat& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_Chat* internal_default_instance() {
    return reinterpret_cast<const Message_Chat*>(
               &_Message_Chat_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  friend void swap(Message_Chat& a, Message_Chat& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_Chat* 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(Message_Chat* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_Chat* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_Chat>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_Chat& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_Chat& from) {
    Message_Chat::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_Chat* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.Chat";
  }
  protected:
  explicit Message_Chat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDisplayNameFieldNumber = 1,
    kIdFieldNumber = 2,
  };
  // 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 id = 2;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.Chat)
 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 id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ContactMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactMessage) */ {
 public:
  inline Message_ContactMessage() : Message_ContactMessage(nullptr) {}
  ~Message_ContactMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ContactMessage(const Message_ContactMessage& from);
  Message_ContactMessage(Message_ContactMessage&& from) noexcept
    : Message_ContactMessage() {
    *this = ::std::move(from);
  }

  inline Message_ContactMessage& operator=(const Message_ContactMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ContactMessage& operator=(Message_ContactMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ContactMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ContactMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ContactMessage*>(
               &_Message_ContactMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  friend void swap(Message_ContactMessage& a, Message_ContactMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ContactMessage* 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(Message_ContactMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ContactMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ContactMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ContactMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ContactMessage& from) {
    Message_ContactMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ContactMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ContactMessage";
  }
  protected:
  explicit Message_ContactMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDisplayNameFieldNumber = 1,
    kVcardFieldNumber = 16,
    kContextInfoFieldNumber = 17,
  };
  // 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 vcard = 16;
  bool has_vcard() const;
  private:
  bool _internal_has_vcard() const;
  public:
  void clear_vcard();
  const std::string& vcard() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_vcard(ArgT0&& arg0, ArgT... args);
  std::string* mutable_vcard();
  PROTOBUF_NODISCARD std::string* release_vcard();
  void set_allocated_vcard(std::string* vcard);
  private:
  const std::string& _internal_vcard() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vcard(const std::string& value);
  std::string* _internal_mutable_vcard();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // @@protoc_insertion_point(class_scope:proto.Message.ContactMessage)
 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 vcard_;
    ::proto::ContextInfo* contextinfo_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ContactsArrayMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ContactsArrayMessage) */ {
 public:
  inline Message_ContactsArrayMessage() : Message_ContactsArrayMessage(nullptr) {}
  ~Message_ContactsArrayMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ContactsArrayMessage(const Message_ContactsArrayMessage& from);
  Message_ContactsArrayMessage(Message_ContactsArrayMessage&& from) noexcept
    : Message_ContactsArrayMessage() {
    *this = ::std::move(from);
  }

  inline Message_ContactsArrayMessage& operator=(const Message_ContactsArrayMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ContactsArrayMessage& operator=(Message_ContactsArrayMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ContactsArrayMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ContactsArrayMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ContactsArrayMessage*>(
               &_Message_ContactsArrayMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  friend void swap(Message_ContactsArrayMessage& a, Message_ContactsArrayMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ContactsArrayMessage* 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(Message_ContactsArrayMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ContactsArrayMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ContactsArrayMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ContactsArrayMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ContactsArrayMessage& from) {
    Message_ContactsArrayMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ContactsArrayMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ContactsArrayMessage";
  }
  protected:
  explicit Message_ContactsArrayMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kContactsFieldNumber = 2,
    kDisplayNameFieldNumber = 1,
    kContextInfoFieldNumber = 17,
  };
  // repeated .proto.Message.ContactMessage contacts = 2;
  int contacts_size() const;
  private:
  int _internal_contacts_size() const;
  public:
  void clear_contacts();
  ::proto::Message_ContactMessage* mutable_contacts(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >*
      mutable_contacts();
  private:
  const ::proto::Message_ContactMessage& _internal_contacts(int index) const;
  ::proto::Message_ContactMessage* _internal_add_contacts();
  public:
  const ::proto::Message_ContactMessage& contacts(int index) const;
  ::proto::Message_ContactMessage* add_contacts();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >&
      contacts() const;

  // 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 .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // @@protoc_insertion_point(class_scope:proto.Message.ContactsArrayMessage)
 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< ::proto::Message_ContactMessage > contacts_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr displayname_;
    ::proto::ContextInfo* contextinfo_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_DeclinePaymentRequestMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeclinePaymentRequestMessage) */ {
 public:
  inline Message_DeclinePaymentRequestMessage() : Message_DeclinePaymentRequestMessage(nullptr) {}
  ~Message_DeclinePaymentRequestMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_DeclinePaymentRequestMessage(const Message_DeclinePaymentRequestMessage& from);
  Message_DeclinePaymentRequestMessage(Message_DeclinePaymentRequestMessage&& from) noexcept
    : Message_DeclinePaymentRequestMessage() {
    *this = ::std::move(from);
  }

  inline Message_DeclinePaymentRequestMessage& operator=(const Message_DeclinePaymentRequestMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_DeclinePaymentRequestMessage& operator=(Message_DeclinePaymentRequestMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_DeclinePaymentRequestMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_DeclinePaymentRequestMessage* internal_default_instance() {
    return reinterpret_cast<const Message_DeclinePaymentRequestMessage*>(
               &_Message_DeclinePaymentRequestMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  friend void swap(Message_DeclinePaymentRequestMessage& a, Message_DeclinePaymentRequestMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_DeclinePaymentRequestMessage* 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(Message_DeclinePaymentRequestMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_DeclinePaymentRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_DeclinePaymentRequestMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_DeclinePaymentRequestMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_DeclinePaymentRequestMessage& from) {
    Message_DeclinePaymentRequestMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_DeclinePaymentRequestMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.DeclinePaymentRequestMessage";
  }
  protected:
  explicit Message_DeclinePaymentRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
  };
  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // @@protoc_insertion_point(class_scope:proto.Message.DeclinePaymentRequestMessage)
 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_;
    ::proto::MessageKey* key_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_DeviceSentMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DeviceSentMessage) */ {
 public:
  inline Message_DeviceSentMessage() : Message_DeviceSentMessage(nullptr) {}
  ~Message_DeviceSentMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_DeviceSentMessage(const Message_DeviceSentMessage& from);
  Message_DeviceSentMessage(Message_DeviceSentMessage&& from) noexcept
    : Message_DeviceSentMessage() {
    *this = ::std::move(from);
  }

  inline Message_DeviceSentMessage& operator=(const Message_DeviceSentMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_DeviceSentMessage& operator=(Message_DeviceSentMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_DeviceSentMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_DeviceSentMessage* internal_default_instance() {
    return reinterpret_cast<const Message_DeviceSentMessage*>(
               &_Message_DeviceSentMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  friend void swap(Message_DeviceSentMessage& a, Message_DeviceSentMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_DeviceSentMessage* 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(Message_DeviceSentMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_DeviceSentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_DeviceSentMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_DeviceSentMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_DeviceSentMessage& from) {
    Message_DeviceSentMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_DeviceSentMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.DeviceSentMessage";
  }
  protected:
  explicit Message_DeviceSentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDestinationJidFieldNumber = 1,
    kPhashFieldNumber = 3,
    kMessageFieldNumber = 2,
  };
  // optional string destinationJid = 1;
  bool has_destinationjid() const;
  private:
  bool _internal_has_destinationjid() const;
  public:
  void clear_destinationjid();
  const std::string& destinationjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_destinationjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_destinationjid();
  PROTOBUF_NODISCARD std::string* release_destinationjid();
  void set_allocated_destinationjid(std::string* destinationjid);
  private:
  const std::string& _internal_destinationjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_destinationjid(const std::string& value);
  std::string* _internal_mutable_destinationjid();
  public:

  // optional string phash = 3;
  bool has_phash() const;
  private:
  bool _internal_has_phash() const;
  public:
  void clear_phash();
  const std::string& phash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_phash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_phash();
  PROTOBUF_NODISCARD std::string* release_phash();
  void set_allocated_phash(std::string* phash);
  private:
  const std::string& _internal_phash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_phash(const std::string& value);
  std::string* _internal_mutable_phash();
  public:

  // optional .proto.Message message = 2;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const ::proto::Message& message() const;
  PROTOBUF_NODISCARD ::proto::Message* release_message();
  ::proto::Message* mutable_message();
  void set_allocated_message(::proto::Message* message);
  private:
  const ::proto::Message& _internal_message() const;
  ::proto::Message* _internal_mutable_message();
  public:
  void unsafe_arena_set_allocated_message(
      ::proto::Message* message);
  ::proto::Message* unsafe_arena_release_message();

  // @@protoc_insertion_point(class_scope:proto.Message.DeviceSentMessage)
 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 destinationjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr phash_;
    ::proto::Message* message_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_DocumentMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.DocumentMessage) */ {
 public:
  inline Message_DocumentMessage() : Message_DocumentMessage(nullptr) {}
  ~Message_DocumentMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_DocumentMessage(const Message_DocumentMessage& from);
  Message_DocumentMessage(Message_DocumentMessage&& from) noexcept
    : Message_DocumentMessage() {
    *this = ::std::move(from);
  }

  inline Message_DocumentMessage& operator=(const Message_DocumentMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_DocumentMessage& operator=(Message_DocumentMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_DocumentMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_DocumentMessage* internal_default_instance() {
    return reinterpret_cast<const Message_DocumentMessage*>(
               &_Message_DocumentMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  friend void swap(Message_DocumentMessage& a, Message_DocumentMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_DocumentMessage* 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(Message_DocumentMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_DocumentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_DocumentMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_DocumentMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_DocumentMessage& from) {
    Message_DocumentMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_DocumentMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.DocumentMessage";
  }
  protected:
  explicit Message_DocumentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUrlFieldNumber = 1,
    kMimetypeFieldNumber = 2,
    kTitleFieldNumber = 3,
    kFileSha256FieldNumber = 4,
    kMediaKeyFieldNumber = 7,
    kFileNameFieldNumber = 8,
    kFileEncSha256FieldNumber = 9,
    kDirectPathFieldNumber = 10,
    kThumbnailDirectPathFieldNumber = 13,
    kThumbnailSha256FieldNumber = 14,
    kThumbnailEncSha256FieldNumber = 15,
    kJpegThumbnailFieldNumber = 16,
    kCaptionFieldNumber = 20,
    kContextInfoFieldNumber = 17,
    kFileLengthFieldNumber = 5,
    kPageCountFieldNumber = 6,
    kContactVcardFieldNumber = 12,
    kMediaKeyTimestampFieldNumber = 11,
    kThumbnailHeightFieldNumber = 18,
    kThumbnailWidthFieldNumber = 19,
  };
  // optional 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 mimetype = 2;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional string title = 3;
  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 bytes fileSha256 = 4;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes mediaKey = 7;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string fileName = 8;
  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 bytes fileEncSha256 = 9;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 10;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional string thumbnailDirectPath = 13;
  bool has_thumbnaildirectpath() const;
  private:
  bool _internal_has_thumbnaildirectpath() const;
  public:
  void clear_thumbnaildirectpath();
  const std::string& thumbnaildirectpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnaildirectpath();
  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
  private:
  const std::string& _internal_thumbnaildirectpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
  std::string* _internal_mutable_thumbnaildirectpath();
  public:

  // optional bytes thumbnailSha256 = 14;
  bool has_thumbnailsha256() const;
  private:
  bool _internal_has_thumbnailsha256() const;
  public:
  void clear_thumbnailsha256();
  const std::string& thumbnailsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
  private:
  const std::string& _internal_thumbnailsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailsha256();
  public:

  // optional bytes thumbnailEncSha256 = 15;
  bool has_thumbnailencsha256() const;
  private:
  bool _internal_has_thumbnailencsha256() const;
  public:
  void clear_thumbnailencsha256();
  const std::string& thumbnailencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailencsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
  private:
  const std::string& _internal_thumbnailencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailencsha256();
  public:

  // optional bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional string caption = 20;
  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 .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint64 fileLength = 5;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional uint32 pageCount = 6;
  bool has_pagecount() const;
  private:
  bool _internal_has_pagecount() const;
  public:
  void clear_pagecount();
  uint32_t pagecount() const;
  void set_pagecount(uint32_t value);
  private:
  uint32_t _internal_pagecount() const;
  void _internal_set_pagecount(uint32_t value);
  public:

  // optional bool contactVcard = 12;
  bool has_contactvcard() const;
  private:
  bool _internal_has_contactvcard() const;
  public:
  void clear_contactvcard();
  bool contactvcard() const;
  void set_contactvcard(bool value);
  private:
  bool _internal_contactvcard() const;
  void _internal_set_contactvcard(bool value);
  public:

  // optional int64 mediaKeyTimestamp = 11;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // optional uint32 thumbnailHeight = 18;
  bool has_thumbnailheight() const;
  private:
  bool _internal_has_thumbnailheight() const;
  public:
  void clear_thumbnailheight();
  uint32_t thumbnailheight() const;
  void set_thumbnailheight(uint32_t value);
  private:
  uint32_t _internal_thumbnailheight() const;
  void _internal_set_thumbnailheight(uint32_t value);
  public:

  // optional uint32 thumbnailWidth = 19;
  bool has_thumbnailwidth() const;
  private:
  bool _internal_has_thumbnailwidth() const;
  public:
  void clear_thumbnailwidth();
  uint32_t thumbnailwidth() const;
  void set_thumbnailwidth(uint32_t value);
  private:
  uint32_t _internal_thumbnailwidth() const;
  void _internal_set_thumbnailwidth(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.DocumentMessage)
 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 mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filename_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::proto::ContextInfo* contextinfo_;
    uint64_t filelength_;
    uint32_t pagecount_;
    bool contactvcard_;
    int64_t mediakeytimestamp_;
    uint32_t thumbnailheight_;
    uint32_t thumbnailwidth_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ExtendedTextMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ExtendedTextMessage) */ {
 public:
  inline Message_ExtendedTextMessage() : Message_ExtendedTextMessage(nullptr) {}
  ~Message_ExtendedTextMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ExtendedTextMessage(const Message_ExtendedTextMessage& from);
  Message_ExtendedTextMessage(Message_ExtendedTextMessage&& from) noexcept
    : Message_ExtendedTextMessage() {
    *this = ::std::move(from);
  }

  inline Message_ExtendedTextMessage& operator=(const Message_ExtendedTextMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ExtendedTextMessage& operator=(Message_ExtendedTextMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ExtendedTextMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ExtendedTextMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ExtendedTextMessage*>(
               &_Message_ExtendedTextMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

  friend void swap(Message_ExtendedTextMessage& a, Message_ExtendedTextMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ExtendedTextMessage* 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(Message_ExtendedTextMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ExtendedTextMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ExtendedTextMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ExtendedTextMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ExtendedTextMessage& from) {
    Message_ExtendedTextMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ExtendedTextMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ExtendedTextMessage";
  }
  protected:
  explicit Message_ExtendedTextMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ExtendedTextMessage_FontType FontType;
  static constexpr FontType SANS_SERIF =
    Message_ExtendedTextMessage_FontType_SANS_SERIF;
  static constexpr FontType SERIF =
    Message_ExtendedTextMessage_FontType_SERIF;
  static constexpr FontType NORICAN_REGULAR =
    Message_ExtendedTextMessage_FontType_NORICAN_REGULAR;
  static constexpr FontType BRYNDAN_WRITE =
    Message_ExtendedTextMessage_FontType_BRYNDAN_WRITE;
  static constexpr FontType BEBASNEUE_REGULAR =
    Message_ExtendedTextMessage_FontType_BEBASNEUE_REGULAR;
  static constexpr FontType OSWALD_HEAVY =
    Message_ExtendedTextMessage_FontType_OSWALD_HEAVY;
  static inline bool FontType_IsValid(int value) {
    return Message_ExtendedTextMessage_FontType_IsValid(value);
  }
  static constexpr FontType FontType_MIN =
    Message_ExtendedTextMessage_FontType_FontType_MIN;
  static constexpr FontType FontType_MAX =
    Message_ExtendedTextMessage_FontType_FontType_MAX;
  static constexpr int FontType_ARRAYSIZE =
    Message_ExtendedTextMessage_FontType_FontType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  FontType_descriptor() {
    return Message_ExtendedTextMessage_FontType_descriptor();
  }
  template<typename T>
  static inline const std::string& FontType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FontType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FontType_Name.");
    return Message_ExtendedTextMessage_FontType_Name(enum_t_value);
  }
  static inline bool FontType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FontType* value) {
    return Message_ExtendedTextMessage_FontType_Parse(name, value);
  }

  typedef Message_ExtendedTextMessage_InviteLinkGroupType InviteLinkGroupType;
  static constexpr InviteLinkGroupType DEFAULT =
    Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT;
  static constexpr InviteLinkGroupType PARENT =
    Message_ExtendedTextMessage_InviteLinkGroupType_PARENT;
  static constexpr InviteLinkGroupType SUB =
    Message_ExtendedTextMessage_InviteLinkGroupType_SUB;
  static constexpr InviteLinkGroupType DEFAULT_SUB =
    Message_ExtendedTextMessage_InviteLinkGroupType_DEFAULT_SUB;
  static inline bool InviteLinkGroupType_IsValid(int value) {
    return Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value);
  }
  static constexpr InviteLinkGroupType InviteLinkGroupType_MIN =
    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MIN;
  static constexpr InviteLinkGroupType InviteLinkGroupType_MAX =
    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_MAX;
  static constexpr int InviteLinkGroupType_ARRAYSIZE =
    Message_ExtendedTextMessage_InviteLinkGroupType_InviteLinkGroupType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  InviteLinkGroupType_descriptor() {
    return Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
  }
  template<typename T>
  static inline const std::string& InviteLinkGroupType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, InviteLinkGroupType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function InviteLinkGroupType_Name.");
    return Message_ExtendedTextMessage_InviteLinkGroupType_Name(enum_t_value);
  }
  static inline bool InviteLinkGroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      InviteLinkGroupType* value) {
    return Message_ExtendedTextMessage_InviteLinkGroupType_Parse(name, value);
  }

  typedef Message_ExtendedTextMessage_PreviewType PreviewType;
  static constexpr PreviewType NONE =
    Message_ExtendedTextMessage_PreviewType_NONE;
  static constexpr PreviewType VIDEO =
    Message_ExtendedTextMessage_PreviewType_VIDEO;
  static inline bool PreviewType_IsValid(int value) {
    return Message_ExtendedTextMessage_PreviewType_IsValid(value);
  }
  static constexpr PreviewType PreviewType_MIN =
    Message_ExtendedTextMessage_PreviewType_PreviewType_MIN;
  static constexpr PreviewType PreviewType_MAX =
    Message_ExtendedTextMessage_PreviewType_PreviewType_MAX;
  static constexpr int PreviewType_ARRAYSIZE =
    Message_ExtendedTextMessage_PreviewType_PreviewType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  PreviewType_descriptor() {
    return Message_ExtendedTextMessage_PreviewType_descriptor();
  }
  template<typename T>
  static inline const std::string& PreviewType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, PreviewType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function PreviewType_Name.");
    return Message_ExtendedTextMessage_PreviewType_Name(enum_t_value);
  }
  static inline bool PreviewType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      PreviewType* value) {
    return Message_ExtendedTextMessage_PreviewType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 1,
    kMatchedTextFieldNumber = 2,
    kCanonicalUrlFieldNumber = 4,
    kDescriptionFieldNumber = 5,
    kTitleFieldNumber = 6,
    kJpegThumbnailFieldNumber = 16,
    kThumbnailDirectPathFieldNumber = 19,
    kThumbnailSha256FieldNumber = 20,
    kThumbnailEncSha256FieldNumber = 21,
    kMediaKeyFieldNumber = 22,
    kInviteLinkParentGroupSubjectV2FieldNumber = 27,
    kInviteLinkParentGroupThumbnailV2FieldNumber = 28,
    kContextInfoFieldNumber = 17,
    kTextArgbFieldNumber = 7,
    kBackgroundArgbFieldNumber = 8,
    kFontFieldNumber = 9,
    kPreviewTypeFieldNumber = 10,
    kDoNotPlayInlineFieldNumber = 18,
    kThumbnailHeightFieldNumber = 24,
    kMediaKeyTimestampFieldNumber = 23,
    kThumbnailWidthFieldNumber = 25,
    kInviteLinkGroupTypeFieldNumber = 26,
    kInviteLinkGroupTypeV2FieldNumber = 29,
  };
  // optional string text = 1;
  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:

  // optional string matchedText = 2;
  bool has_matchedtext() const;
  private:
  bool _internal_has_matchedtext() const;
  public:
  void clear_matchedtext();
  const std::string& matchedtext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_matchedtext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_matchedtext();
  PROTOBUF_NODISCARD std::string* release_matchedtext();
  void set_allocated_matchedtext(std::string* matchedtext);
  private:
  const std::string& _internal_matchedtext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value);
  std::string* _internal_mutable_matchedtext();
  public:

  // optional string canonicalUrl = 4;
  bool has_canonicalurl() const;
  private:
  bool _internal_has_canonicalurl() const;
  public:
  void clear_canonicalurl();
  const std::string& canonicalurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_canonicalurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_canonicalurl();
  PROTOBUF_NODISCARD std::string* release_canonicalurl();
  void set_allocated_canonicalurl(std::string* canonicalurl);
  private:
  const std::string& _internal_canonicalurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value);
  std::string* _internal_mutable_canonicalurl();
  public:

  // optional string description = 5;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional string title = 6;
  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 bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional string thumbnailDirectPath = 19;
  bool has_thumbnaildirectpath() const;
  private:
  bool _internal_has_thumbnaildirectpath() const;
  public:
  void clear_thumbnaildirectpath();
  const std::string& thumbnaildirectpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnaildirectpath();
  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
  private:
  const std::string& _internal_thumbnaildirectpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
  std::string* _internal_mutable_thumbnaildirectpath();
  public:

  // optional bytes thumbnailSha256 = 20;
  bool has_thumbnailsha256() const;
  private:
  bool _internal_has_thumbnailsha256() const;
  public:
  void clear_thumbnailsha256();
  const std::string& thumbnailsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
  private:
  const std::string& _internal_thumbnailsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailsha256();
  public:

  // optional bytes thumbnailEncSha256 = 21;
  bool has_thumbnailencsha256() const;
  private:
  bool _internal_has_thumbnailencsha256() const;
  public:
  void clear_thumbnailencsha256();
  const std::string& thumbnailencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailencsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
  private:
  const std::string& _internal_thumbnailencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailencsha256();
  public:

  // optional bytes mediaKey = 22;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string inviteLinkParentGroupSubjectV2 = 27;
  bool has_invitelinkparentgroupsubjectv2() const;
  private:
  bool _internal_has_invitelinkparentgroupsubjectv2() const;
  public:
  void clear_invitelinkparentgroupsubjectv2();
  const std::string& invitelinkparentgroupsubjectv2() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args);
  std::string* mutable_invitelinkparentgroupsubjectv2();
  PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupsubjectv2();
  void set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2);
  private:
  const std::string& _internal_invitelinkparentgroupsubjectv2() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupsubjectv2(const std::string& value);
  std::string* _internal_mutable_invitelinkparentgroupsubjectv2();
  public:

  // optional bytes inviteLinkParentGroupThumbnailV2 = 28;
  bool has_invitelinkparentgroupthumbnailv2() const;
  private:
  bool _internal_has_invitelinkparentgroupthumbnailv2() const;
  public:
  void clear_invitelinkparentgroupthumbnailv2();
  const std::string& invitelinkparentgroupthumbnailv2() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args);
  std::string* mutable_invitelinkparentgroupthumbnailv2();
  PROTOBUF_NODISCARD std::string* release_invitelinkparentgroupthumbnailv2();
  void set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2);
  private:
  const std::string& _internal_invitelinkparentgroupthumbnailv2() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitelinkparentgroupthumbnailv2(const std::string& value);
  std::string* _internal_mutable_invitelinkparentgroupthumbnailv2();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional fixed32 textArgb = 7;
  bool has_textargb() const;
  private:
  bool _internal_has_textargb() const;
  public:
  void clear_textargb();
  uint32_t textargb() const;
  void set_textargb(uint32_t value);
  private:
  uint32_t _internal_textargb() const;
  void _internal_set_textargb(uint32_t value);
  public:

  // optional fixed32 backgroundArgb = 8;
  bool has_backgroundargb() const;
  private:
  bool _internal_has_backgroundargb() const;
  public:
  void clear_backgroundargb();
  uint32_t backgroundargb() const;
  void set_backgroundargb(uint32_t value);
  private:
  uint32_t _internal_backgroundargb() const;
  void _internal_set_backgroundargb(uint32_t value);
  public:

  // optional .proto.Message.ExtendedTextMessage.FontType font = 9;
  bool has_font() const;
  private:
  bool _internal_has_font() const;
  public:
  void clear_font();
  ::proto::Message_ExtendedTextMessage_FontType font() const;
  void set_font(::proto::Message_ExtendedTextMessage_FontType value);
  private:
  ::proto::Message_ExtendedTextMessage_FontType _internal_font() const;
  void _internal_set_font(::proto::Message_ExtendedTextMessage_FontType value);
  public:

  // optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
  bool has_previewtype() const;
  private:
  bool _internal_has_previewtype() const;
  public:
  void clear_previewtype();
  ::proto::Message_ExtendedTextMessage_PreviewType previewtype() const;
  void set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value);
  private:
  ::proto::Message_ExtendedTextMessage_PreviewType _internal_previewtype() const;
  void _internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value);
  public:

  // optional bool doNotPlayInline = 18;
  bool has_donotplayinline() const;
  private:
  bool _internal_has_donotplayinline() const;
  public:
  void clear_donotplayinline();
  bool donotplayinline() const;
  void set_donotplayinline(bool value);
  private:
  bool _internal_donotplayinline() const;
  void _internal_set_donotplayinline(bool value);
  public:

  // optional uint32 thumbnailHeight = 24;
  bool has_thumbnailheight() const;
  private:
  bool _internal_has_thumbnailheight() const;
  public:
  void clear_thumbnailheight();
  uint32_t thumbnailheight() const;
  void set_thumbnailheight(uint32_t value);
  private:
  uint32_t _internal_thumbnailheight() const;
  void _internal_set_thumbnailheight(uint32_t value);
  public:

  // optional int64 mediaKeyTimestamp = 23;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // optional uint32 thumbnailWidth = 25;
  bool has_thumbnailwidth() const;
  private:
  bool _internal_has_thumbnailwidth() const;
  public:
  void clear_thumbnailwidth();
  uint32_t thumbnailwidth() const;
  void set_thumbnailwidth(uint32_t value);
  private:
  uint32_t _internal_thumbnailwidth() const;
  void _internal_set_thumbnailwidth(uint32_t value);
  public:

  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
  bool has_invitelinkgrouptype() const;
  private:
  bool _internal_has_invitelinkgrouptype() const;
  public:
  void clear_invitelinkgrouptype();
  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptype() const;
  void set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
  private:
  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptype() const;
  void _internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
  public:

  // optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
  bool has_invitelinkgrouptypev2() const;
  private:
  bool _internal_has_invitelinkgrouptypev2() const;
  public:
  void clear_invitelinkgrouptypev2();
  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType invitelinkgrouptypev2() const;
  void set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
  private:
  ::proto::Message_ExtendedTextMessage_InviteLinkGroupType _internal_invitelinkgrouptypev2() const;
  void _internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ExtendedTextMessage)
 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 text_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupsubjectv2_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitelinkparentgroupthumbnailv2_;
    ::proto::ContextInfo* contextinfo_;
    uint32_t textargb_;
    uint32_t backgroundargb_;
    int font_;
    int previewtype_;
    bool donotplayinline_;
    uint32_t thumbnailheight_;
    int64_t mediakeytimestamp_;
    uint32_t thumbnailwidth_;
    int invitelinkgrouptype_;
    int invitelinkgrouptypev2_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_FutureProofMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.FutureProofMessage) */ {
 public:
  inline Message_FutureProofMessage() : Message_FutureProofMessage(nullptr) {}
  ~Message_FutureProofMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_FutureProofMessage(const Message_FutureProofMessage& from);
  Message_FutureProofMessage(Message_FutureProofMessage&& from) noexcept
    : Message_FutureProofMessage() {
    *this = ::std::move(from);
  }

  inline Message_FutureProofMessage& operator=(const Message_FutureProofMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_FutureProofMessage& operator=(Message_FutureProofMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_FutureProofMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_FutureProofMessage* internal_default_instance() {
    return reinterpret_cast<const Message_FutureProofMessage*>(
               &_Message_FutureProofMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

  friend void swap(Message_FutureProofMessage& a, Message_FutureProofMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_FutureProofMessage* 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(Message_FutureProofMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_FutureProofMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_FutureProofMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_FutureProofMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_FutureProofMessage& from) {
    Message_FutureProofMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_FutureProofMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.FutureProofMessage";
  }
  protected:
  explicit Message_FutureProofMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageFieldNumber = 1,
  };
  // optional .proto.Message message = 1;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const ::proto::Message& message() const;
  PROTOBUF_NODISCARD ::proto::Message* release_message();
  ::proto::Message* mutable_message();
  void set_allocated_message(::proto::Message* message);
  private:
  const ::proto::Message& _internal_message() const;
  ::proto::Message* _internal_mutable_message();
  public:
  void unsafe_arena_set_allocated_message(
      ::proto::Message* message);
  ::proto::Message* unsafe_arena_release_message();

  // @@protoc_insertion_point(class_scope:proto.Message.FutureProofMessage)
 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_;
    ::proto::Message* message_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_GroupInviteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.GroupInviteMessage) */ {
 public:
  inline Message_GroupInviteMessage() : Message_GroupInviteMessage(nullptr) {}
  ~Message_GroupInviteMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_GroupInviteMessage(const Message_GroupInviteMessage& from);
  Message_GroupInviteMessage(Message_GroupInviteMessage&& from) noexcept
    : Message_GroupInviteMessage() {
    *this = ::std::move(from);
  }

  inline Message_GroupInviteMessage& operator=(const Message_GroupInviteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_GroupInviteMessage& operator=(Message_GroupInviteMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_GroupInviteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_GroupInviteMessage* internal_default_instance() {
    return reinterpret_cast<const Message_GroupInviteMessage*>(
               &_Message_GroupInviteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

  friend void swap(Message_GroupInviteMessage& a, Message_GroupInviteMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_GroupInviteMessage* 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(Message_GroupInviteMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_GroupInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_GroupInviteMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_GroupInviteMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_GroupInviteMessage& from) {
    Message_GroupInviteMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_GroupInviteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.GroupInviteMessage";
  }
  protected:
  explicit Message_GroupInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_GroupInviteMessage_GroupType GroupType;
  static constexpr GroupType DEFAULT =
    Message_GroupInviteMessage_GroupType_DEFAULT;
  static constexpr GroupType PARENT =
    Message_GroupInviteMessage_GroupType_PARENT;
  static inline bool GroupType_IsValid(int value) {
    return Message_GroupInviteMessage_GroupType_IsValid(value);
  }
  static constexpr GroupType GroupType_MIN =
    Message_GroupInviteMessage_GroupType_GroupType_MIN;
  static constexpr GroupType GroupType_MAX =
    Message_GroupInviteMessage_GroupType_GroupType_MAX;
  static constexpr int GroupType_ARRAYSIZE =
    Message_GroupInviteMessage_GroupType_GroupType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  GroupType_descriptor() {
    return Message_GroupInviteMessage_GroupType_descriptor();
  }
  template<typename T>
  static inline const std::string& GroupType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, GroupType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function GroupType_Name.");
    return Message_GroupInviteMessage_GroupType_Name(enum_t_value);
  }
  static inline bool GroupType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      GroupType* value) {
    return Message_GroupInviteMessage_GroupType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kGroupJidFieldNumber = 1,
    kInviteCodeFieldNumber = 2,
    kGroupNameFieldNumber = 4,
    kJpegThumbnailFieldNumber = 5,
    kCaptionFieldNumber = 6,
    kContextInfoFieldNumber = 7,
    kInviteExpirationFieldNumber = 3,
    kGroupTypeFieldNumber = 8,
  };
  // optional string groupJid = 1;
  bool has_groupjid() const;
  private:
  bool _internal_has_groupjid() const;
  public:
  void clear_groupjid();
  const std::string& groupjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupjid();
  PROTOBUF_NODISCARD std::string* release_groupjid();
  void set_allocated_groupjid(std::string* groupjid);
  private:
  const std::string& _internal_groupjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value);
  std::string* _internal_mutable_groupjid();
  public:

  // optional string inviteCode = 2;
  bool has_invitecode() const;
  private:
  bool _internal_has_invitecode() const;
  public:
  void clear_invitecode();
  const std::string& invitecode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_invitecode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_invitecode();
  PROTOBUF_NODISCARD std::string* release_invitecode();
  void set_allocated_invitecode(std::string* invitecode);
  private:
  const std::string& _internal_invitecode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_invitecode(const std::string& value);
  std::string* _internal_mutable_invitecode();
  public:

  // optional string groupName = 4;
  bool has_groupname() const;
  private:
  bool _internal_has_groupname() const;
  public:
  void clear_groupname();
  const std::string& groupname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupname();
  PROTOBUF_NODISCARD std::string* release_groupname();
  void set_allocated_groupname(std::string* groupname);
  private:
  const std::string& _internal_groupname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupname(const std::string& value);
  std::string* _internal_mutable_groupname();
  public:

  // optional bytes jpegThumbnail = 5;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional string caption = 6;
  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 .proto.ContextInfo contextInfo = 7;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional int64 inviteExpiration = 3;
  bool has_inviteexpiration() const;
  private:
  bool _internal_has_inviteexpiration() const;
  public:
  void clear_inviteexpiration();
  int64_t inviteexpiration() const;
  void set_inviteexpiration(int64_t value);
  private:
  int64_t _internal_inviteexpiration() const;
  void _internal_set_inviteexpiration(int64_t value);
  public:

  // optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
  bool has_grouptype() const;
  private:
  bool _internal_has_grouptype() const;
  public:
  void clear_grouptype();
  ::proto::Message_GroupInviteMessage_GroupType grouptype() const;
  void set_grouptype(::proto::Message_GroupInviteMessage_GroupType value);
  private:
  ::proto::Message_GroupInviteMessage_GroupType _internal_grouptype() const;
  void _internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.GroupInviteMessage)
 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 groupjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr invitecode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::proto::ContextInfo* contextinfo_;
    int64_t inviteexpiration_;
    int grouptype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency) */ {
 public:
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(nullptr) {}
  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from);
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept
    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency*>(
               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* 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(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& from) {
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency";
  }
  protected:
  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCurrencyCodeFieldNumber = 1,
    kAmount1000FieldNumber = 2,
  };
  // optional string currencyCode = 1;
  bool has_currencycode() const;
  private:
  bool _internal_has_currencycode() const;
  public:
  void clear_currencycode();
  const std::string& currencycode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_currencycode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_currencycode();
  PROTOBUF_NODISCARD std::string* release_currencycode();
  void set_allocated_currencycode(std::string* currencycode);
  private:
  const std::string& _internal_currencycode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
  std::string* _internal_mutable_currencycode();
  public:

  // optional int64 amount1000 = 2;
  bool has_amount1000() const;
  private:
  bool _internal_has_amount1000() const;
  public:
  void clear_amount1000();
  int64_t amount1000() const;
  void set_amount1000(int64_t value);
  private:
  int64_t _internal_amount1000() const;
  void _internal_set_amount1000(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency)
 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 currencycode_;
    int64_t amount1000_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent) */ {
 public:
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(nullptr) {}
  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from);
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept
    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent*>(
               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* 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(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& from) {
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent";
  }
  protected:
  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType CalendarType;
  static constexpr CalendarType GREGORIAN =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_GREGORIAN;
  static constexpr CalendarType SOLAR_HIJRI =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_SOLAR_HIJRI;
  static inline bool CalendarType_IsValid(int value) {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value);
  }
  static constexpr CalendarType CalendarType_MIN =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MIN;
  static constexpr CalendarType CalendarType_MAX =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_MAX;
  static constexpr int CalendarType_ARRAYSIZE =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_CalendarType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  CalendarType_descriptor() {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
  }
  template<typename T>
  static inline const std::string& CalendarType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CalendarType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CalendarType_Name.");
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Name(enum_t_value);
  }
  static inline bool CalendarType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      CalendarType* value) {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_Parse(name, value);
  }

  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType DayOfWeekType;
  static constexpr DayOfWeekType MONDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_MONDAY;
  static constexpr DayOfWeekType TUESDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_TUESDAY;
  static constexpr DayOfWeekType WEDNESDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_WEDNESDAY;
  static constexpr DayOfWeekType THURSDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_THURSDAY;
  static constexpr DayOfWeekType FRIDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_FRIDAY;
  static constexpr DayOfWeekType SATURDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SATURDAY;
  static constexpr DayOfWeekType SUNDAY =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_SUNDAY;
  static inline bool DayOfWeekType_IsValid(int value) {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value);
  }
  static constexpr DayOfWeekType DayOfWeekType_MIN =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MIN;
  static constexpr DayOfWeekType DayOfWeekType_MAX =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_MAX;
  static constexpr int DayOfWeekType_ARRAYSIZE =
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_DayOfWeekType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DayOfWeekType_descriptor() {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
  }
  template<typename T>
  static inline const std::string& DayOfWeekType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DayOfWeekType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DayOfWeekType_Name.");
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Name(enum_t_value);
  }
  static inline bool DayOfWeekType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DayOfWeekType* value) {
    return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kYearFieldNumber = 2,
    kMonthFieldNumber = 3,
    kDayOfMonthFieldNumber = 4,
    kHourFieldNumber = 5,
    kMinuteFieldNumber = 6,
    kDayOfWeekFieldNumber = 1,
    kCalendarFieldNumber = 7,
  };
  // optional uint32 year = 2;
  bool has_year() const;
  private:
  bool _internal_has_year() const;
  public:
  void clear_year();
  uint32_t year() const;
  void set_year(uint32_t value);
  private:
  uint32_t _internal_year() const;
  void _internal_set_year(uint32_t value);
  public:

  // optional uint32 month = 3;
  bool has_month() const;
  private:
  bool _internal_has_month() const;
  public:
  void clear_month();
  uint32_t month() const;
  void set_month(uint32_t value);
  private:
  uint32_t _internal_month() const;
  void _internal_set_month(uint32_t value);
  public:

  // optional uint32 dayOfMonth = 4;
  bool has_dayofmonth() const;
  private:
  bool _internal_has_dayofmonth() const;
  public:
  void clear_dayofmonth();
  uint32_t dayofmonth() const;
  void set_dayofmonth(uint32_t value);
  private:
  uint32_t _internal_dayofmonth() const;
  void _internal_set_dayofmonth(uint32_t value);
  public:

  // optional uint32 hour = 5;
  bool has_hour() const;
  private:
  bool _internal_has_hour() const;
  public:
  void clear_hour();
  uint32_t hour() const;
  void set_hour(uint32_t value);
  private:
  uint32_t _internal_hour() const;
  void _internal_set_hour(uint32_t value);
  public:

  // optional uint32 minute = 6;
  bool has_minute() const;
  private:
  bool _internal_has_minute() const;
  public:
  void clear_minute();
  uint32_t minute() const;
  void set_minute(uint32_t value);
  private:
  uint32_t _internal_minute() const;
  void _internal_set_minute(uint32_t value);
  public:

  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
  bool has_dayofweek() const;
  private:
  bool _internal_has_dayofweek() const;
  public:
  void clear_dayofweek();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType dayofweek() const;
  void set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value);
  private:
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType _internal_dayofweek() const;
  void _internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value);
  public:

  // optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
  bool has_calendar() const;
  private:
  bool _internal_has_calendar() const;
  public:
  void clear_calendar();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType calendar() const;
  void set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value);
  private:
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType _internal_calendar() const;
  void _internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent)
 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_;
    uint32_t year_;
    uint32_t month_;
    uint32_t dayofmonth_;
    uint32_t hour_;
    uint32_t minute_;
    int dayofweek_;
    int calendar_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch) */ {
 public:
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(nullptr) {}
  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from);
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept
    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch*>(
               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* 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(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& from) {
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch";
  }
  protected:
  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTimestampFieldNumber = 1,
  };
  // optional int64 timestamp = 1;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch)
 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_;
    int64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime) */ {
 public:
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(nullptr) {}
  ~Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from);
  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept
    : Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& default_instance() {
    return *internal_default_instance();
  }
  enum DatetimeOneofCase {
    kComponent = 1,
    kUnixEpoch = 2,
    DATETIMEONEOF_NOT_SET = 0,
  };

  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime*>(
               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& a, Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* 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(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& from) {
    Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime";
  }
  protected:
  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent HSMDateTimeComponent;
  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch HSMDateTimeUnixEpoch;

  // accessors -------------------------------------------------------

  enum : int {
    kComponentFieldNumber = 1,
    kUnixEpochFieldNumber = 2,
  };
  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
  bool has_component() const;
  private:
  bool _internal_has_component() const;
  public:
  void clear_component();
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& component() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* release_component();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* mutable_component();
  void set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component);
  private:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& _internal_component() const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _internal_mutable_component();
  public:
  void unsafe_arena_set_allocated_component(
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component);
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* unsafe_arena_release_component();

  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
  bool has_unixepoch() const;
  private:
  bool _internal_has_unixepoch() const;
  public:
  void clear_unixepoch();
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& unixepoch() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* release_unixepoch();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* mutable_unixepoch();
  void set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch);
  private:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& _internal_unixepoch() const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _internal_mutable_unixepoch();
  public:
  void unsafe_arena_set_allocated_unixepoch(
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch);
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unsafe_arena_release_unixepoch();

  void clear_datetimeOneof();
  DatetimeOneofCase datetimeOneof_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime)
 private:
  class _Internal;
  void set_has_component();
  void set_has_unixepoch();

  inline bool has_datetimeOneof() const;
  inline void clear_has_datetimeOneof();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    union DatetimeOneofUnion {
      constexpr DatetimeOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component_;
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch_;
    } datetimeOneof_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage_HSMLocalizableParameter final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter) */ {
 public:
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter() : Message_HighlyStructuredMessage_HSMLocalizableParameter(nullptr) {}
  ~Message_HighlyStructuredMessage_HSMLocalizableParameter() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage_HSMLocalizableParameter(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from);
  Message_HighlyStructuredMessage_HSMLocalizableParameter(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept
    : Message_HighlyStructuredMessage_HSMLocalizableParameter() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage_HSMLocalizableParameter& operator=(Message_HighlyStructuredMessage_HSMLocalizableParameter&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage_HSMLocalizableParameter& default_instance() {
    return *internal_default_instance();
  }
  enum ParamOneofCase {
    kCurrency = 2,
    kDateTime = 3,
    PARAMONEOF_NOT_SET = 0,
  };

  static inline const Message_HighlyStructuredMessage_HSMLocalizableParameter* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage_HSMLocalizableParameter*>(
               &_Message_HighlyStructuredMessage_HSMLocalizableParameter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  friend void swap(Message_HighlyStructuredMessage_HSMLocalizableParameter& a, Message_HighlyStructuredMessage_HSMLocalizableParameter& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage_HSMLocalizableParameter* 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(Message_HighlyStructuredMessage_HSMLocalizableParameter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage_HSMLocalizableParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage_HSMLocalizableParameter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage_HSMLocalizableParameter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage_HSMLocalizableParameter& from) {
    Message_HighlyStructuredMessage_HSMLocalizableParameter::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage_HSMLocalizableParameter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage.HSMLocalizableParameter";
  }
  protected:
  explicit Message_HighlyStructuredMessage_HSMLocalizableParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency HSMCurrency;
  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime HSMDateTime;

  // accessors -------------------------------------------------------

  enum : int {
    kDefaultFieldNumber = 1,
    kCurrencyFieldNumber = 2,
    kDateTimeFieldNumber = 3,
  };
  // optional string default = 1;
  bool has_default_() const;
  private:
  bool _internal_has_default_() const;
  public:
  void clear_default_();
  const std::string& default_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_default_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_default_();
  PROTOBUF_NODISCARD std::string* release_default_();
  void set_allocated_default_(std::string* default_);
  private:
  const std::string& _internal_default_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_(const std::string& value);
  std::string* _internal_mutable_default_();
  public:

  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
  bool has_currency() const;
  private:
  bool _internal_has_currency() const;
  public:
  void clear_currency();
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& currency() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* release_currency();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* mutable_currency();
  void set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency);
  private:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& _internal_currency() const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _internal_mutable_currency();
  public:
  void unsafe_arena_set_allocated_currency(
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency);
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* unsafe_arena_release_currency();

  // .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
  bool has_datetime() const;
  private:
  bool _internal_has_datetime() const;
  public:
  void clear_datetime();
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& datetime() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* release_datetime();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* mutable_datetime();
  void set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime);
  private:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& _internal_datetime() const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _internal_mutable_datetime();
  public:
  void unsafe_arena_set_allocated_datetime(
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime);
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* unsafe_arena_release_datetime();

  void clear_paramOneof();
  ParamOneofCase paramOneof_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter)
 private:
  class _Internal;
  void set_has_currency();
  void set_has_datetime();

  inline bool has_paramOneof() const;
  inline void clear_has_paramOneof();

  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 default__;
    union ParamOneofUnion {
      constexpr ParamOneofUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency_;
      ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime_;
    } paramOneof_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HighlyStructuredMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HighlyStructuredMessage) */ {
 public:
  inline Message_HighlyStructuredMessage() : Message_HighlyStructuredMessage(nullptr) {}
  ~Message_HighlyStructuredMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HighlyStructuredMessage(const Message_HighlyStructuredMessage& from);
  Message_HighlyStructuredMessage(Message_HighlyStructuredMessage&& from) noexcept
    : Message_HighlyStructuredMessage() {
    *this = ::std::move(from);
  }

  inline Message_HighlyStructuredMessage& operator=(const Message_HighlyStructuredMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HighlyStructuredMessage& operator=(Message_HighlyStructuredMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HighlyStructuredMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_HighlyStructuredMessage* internal_default_instance() {
    return reinterpret_cast<const Message_HighlyStructuredMessage*>(
               &_Message_HighlyStructuredMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  friend void swap(Message_HighlyStructuredMessage& a, Message_HighlyStructuredMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HighlyStructuredMessage* 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(Message_HighlyStructuredMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HighlyStructuredMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HighlyStructuredMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HighlyStructuredMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HighlyStructuredMessage& from) {
    Message_HighlyStructuredMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HighlyStructuredMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HighlyStructuredMessage";
  }
  protected:
  explicit Message_HighlyStructuredMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_HighlyStructuredMessage_HSMLocalizableParameter HSMLocalizableParameter;

  // accessors -------------------------------------------------------

  enum : int {
    kParamsFieldNumber = 3,
    kLocalizableParamsFieldNumber = 6,
    kNamespaceFieldNumber = 1,
    kElementNameFieldNumber = 2,
    kFallbackLgFieldNumber = 4,
    kFallbackLcFieldNumber = 5,
    kDeterministicLgFieldNumber = 7,
    kDeterministicLcFieldNumber = 8,
    kHydratedHsmFieldNumber = 9,
  };
  // repeated string params = 3;
  int params_size() const;
  private:
  int _internal_params_size() const;
  public:
  void clear_params();
  const std::string& params(int index) const;
  std::string* mutable_params(int index);
  void set_params(int index, const std::string& value);
  void set_params(int index, std::string&& value);
  void set_params(int index, const char* value);
  void set_params(int index, const char* value, size_t size);
  std::string* add_params();
  void add_params(const std::string& value);
  void add_params(std::string&& value);
  void add_params(const char* value);
  void add_params(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& params() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_params();
  private:
  const std::string& _internal_params(int index) const;
  std::string* _internal_add_params();
  public:

  // repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
  int localizableparams_size() const;
  private:
  int _internal_localizableparams_size() const;
  public:
  void clear_localizableparams();
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* mutable_localizableparams(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >*
      mutable_localizableparams();
  private:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& _internal_localizableparams(int index) const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _internal_add_localizableparams();
  public:
  const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& localizableparams(int index) const;
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* add_localizableparams();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >&
      localizableparams() const;

  // optional string namespace = 1;
  bool has_namespace_() const;
  private:
  bool _internal_has_namespace_() const;
  public:
  void clear_namespace_();
  const std::string& namespace_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_namespace_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_namespace_();
  PROTOBUF_NODISCARD std::string* release_namespace_();
  void set_allocated_namespace_(std::string* namespace_);
  private:
  const std::string& _internal_namespace_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
  std::string* _internal_mutable_namespace_();
  public:

  // optional string elementName = 2;
  bool has_elementname() const;
  private:
  bool _internal_has_elementname() const;
  public:
  void clear_elementname();
  const std::string& elementname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_elementname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_elementname();
  PROTOBUF_NODISCARD std::string* release_elementname();
  void set_allocated_elementname(std::string* elementname);
  private:
  const std::string& _internal_elementname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_elementname(const std::string& value);
  std::string* _internal_mutable_elementname();
  public:

  // optional string fallbackLg = 4;
  bool has_fallbacklg() const;
  private:
  bool _internal_has_fallbacklg() const;
  public:
  void clear_fallbacklg();
  const std::string& fallbacklg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fallbacklg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fallbacklg();
  PROTOBUF_NODISCARD std::string* release_fallbacklg();
  void set_allocated_fallbacklg(std::string* fallbacklg);
  private:
  const std::string& _internal_fallbacklg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklg(const std::string& value);
  std::string* _internal_mutable_fallbacklg();
  public:

  // optional string fallbackLc = 5;
  bool has_fallbacklc() const;
  private:
  bool _internal_has_fallbacklc() const;
  public:
  void clear_fallbacklc();
  const std::string& fallbacklc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fallbacklc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fallbacklc();
  PROTOBUF_NODISCARD std::string* release_fallbacklc();
  void set_allocated_fallbacklc(std::string* fallbacklc);
  private:
  const std::string& _internal_fallbacklc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fallbacklc(const std::string& value);
  std::string* _internal_mutable_fallbacklc();
  public:

  // optional string deterministicLg = 7;
  bool has_deterministiclg() const;
  private:
  bool _internal_has_deterministiclg() const;
  public:
  void clear_deterministiclg();
  const std::string& deterministiclg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_deterministiclg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_deterministiclg();
  PROTOBUF_NODISCARD std::string* release_deterministiclg();
  void set_allocated_deterministiclg(std::string* deterministiclg);
  private:
  const std::string& _internal_deterministiclg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclg(const std::string& value);
  std::string* _internal_mutable_deterministiclg();
  public:

  // optional string deterministicLc = 8;
  bool has_deterministiclc() const;
  private:
  bool _internal_has_deterministiclc() const;
  public:
  void clear_deterministiclc();
  const std::string& deterministiclc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_deterministiclc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_deterministiclc();
  PROTOBUF_NODISCARD std::string* release_deterministiclc();
  void set_allocated_deterministiclc(std::string* deterministiclc);
  private:
  const std::string& _internal_deterministiclc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_deterministiclc(const std::string& value);
  std::string* _internal_mutable_deterministiclc();
  public:

  // optional .proto.Message.TemplateMessage hydratedHsm = 9;
  bool has_hydratedhsm() const;
  private:
  bool _internal_has_hydratedhsm() const;
  public:
  void clear_hydratedhsm();
  const ::proto::Message_TemplateMessage& hydratedhsm() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_hydratedhsm();
  ::proto::Message_TemplateMessage* mutable_hydratedhsm();
  void set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm);
  private:
  const ::proto::Message_TemplateMessage& _internal_hydratedhsm() const;
  ::proto::Message_TemplateMessage* _internal_mutable_hydratedhsm();
  public:
  void unsafe_arena_set_allocated_hydratedhsm(
      ::proto::Message_TemplateMessage* hydratedhsm);
  ::proto::Message_TemplateMessage* unsafe_arena_release_hydratedhsm();

  // @@protoc_insertion_point(class_scope:proto.Message.HighlyStructuredMessage)
 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> params_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter > localizableparams_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr elementname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fallbacklc_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclg_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deterministiclc_;
    ::proto::Message_TemplateMessage* hydratedhsm_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_HistorySyncNotification final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.HistorySyncNotification) */ {
 public:
  inline Message_HistorySyncNotification() : Message_HistorySyncNotification(nullptr) {}
  ~Message_HistorySyncNotification() override;
  explicit PROTOBUF_CONSTEXPR Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_HistorySyncNotification(const Message_HistorySyncNotification& from);
  Message_HistorySyncNotification(Message_HistorySyncNotification&& from) noexcept
    : Message_HistorySyncNotification() {
    *this = ::std::move(from);
  }

  inline Message_HistorySyncNotification& operator=(const Message_HistorySyncNotification& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_HistorySyncNotification& operator=(Message_HistorySyncNotification&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_HistorySyncNotification& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_HistorySyncNotification* internal_default_instance() {
    return reinterpret_cast<const Message_HistorySyncNotification*>(
               &_Message_HistorySyncNotification_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    83;

  friend void swap(Message_HistorySyncNotification& a, Message_HistorySyncNotification& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_HistorySyncNotification* 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(Message_HistorySyncNotification* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_HistorySyncNotification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_HistorySyncNotification>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_HistorySyncNotification& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_HistorySyncNotification& from) {
    Message_HistorySyncNotification::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_HistorySyncNotification* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.HistorySyncNotification";
  }
  protected:
  explicit Message_HistorySyncNotification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_HistorySyncNotification_HistorySyncType HistorySyncType;
  static constexpr HistorySyncType INITIAL_BOOTSTRAP =
    Message_HistorySyncNotification_HistorySyncType_INITIAL_BOOTSTRAP;
  static constexpr HistorySyncType INITIAL_STATUS_V3 =
    Message_HistorySyncNotification_HistorySyncType_INITIAL_STATUS_V3;
  static constexpr HistorySyncType FULL =
    Message_HistorySyncNotification_HistorySyncType_FULL;
  static constexpr HistorySyncType RECENT =
    Message_HistorySyncNotification_HistorySyncType_RECENT;
  static constexpr HistorySyncType PUSH_NAME =
    Message_HistorySyncNotification_HistorySyncType_PUSH_NAME;
  static inline bool HistorySyncType_IsValid(int value) {
    return Message_HistorySyncNotification_HistorySyncType_IsValid(value);
  }
  static constexpr HistorySyncType HistorySyncType_MIN =
    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MIN;
  static constexpr HistorySyncType HistorySyncType_MAX =
    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_MAX;
  static constexpr int HistorySyncType_ARRAYSIZE =
    Message_HistorySyncNotification_HistorySyncType_HistorySyncType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  HistorySyncType_descriptor() {
    return Message_HistorySyncNotification_HistorySyncType_descriptor();
  }
  template<typename T>
  static inline const std::string& HistorySyncType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HistorySyncType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HistorySyncType_Name.");
    return Message_HistorySyncNotification_HistorySyncType_Name(enum_t_value);
  }
  static inline bool HistorySyncType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      HistorySyncType* value) {
    return Message_HistorySyncNotification_HistorySyncType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kFileSha256FieldNumber = 1,
    kMediaKeyFieldNumber = 3,
    kFileEncSha256FieldNumber = 4,
    kDirectPathFieldNumber = 5,
    kOriginalMessageIdFieldNumber = 8,
    kFileLengthFieldNumber = 2,
    kSyncTypeFieldNumber = 6,
    kChunkOrderFieldNumber = 7,
    kProgressFieldNumber = 9,
  };
  // optional bytes fileSha256 = 1;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes mediaKey = 3;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional bytes fileEncSha256 = 4;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 5;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional string originalMessageId = 8;
  bool has_originalmessageid() const;
  private:
  bool _internal_has_originalmessageid() const;
  public:
  void clear_originalmessageid();
  const std::string& originalmessageid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_originalmessageid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_originalmessageid();
  PROTOBUF_NODISCARD std::string* release_originalmessageid();
  void set_allocated_originalmessageid(std::string* originalmessageid);
  private:
  const std::string& _internal_originalmessageid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalmessageid(const std::string& value);
  std::string* _internal_mutable_originalmessageid();
  public:

  // optional uint64 fileLength = 2;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
  bool has_synctype() const;
  private:
  bool _internal_has_synctype() const;
  public:
  void clear_synctype();
  ::proto::Message_HistorySyncNotification_HistorySyncType synctype() const;
  void set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value);
  private:
  ::proto::Message_HistorySyncNotification_HistorySyncType _internal_synctype() const;
  void _internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value);
  public:

  // optional uint32 chunkOrder = 7;
  bool has_chunkorder() const;
  private:
  bool _internal_has_chunkorder() const;
  public:
  void clear_chunkorder();
  uint32_t chunkorder() const;
  void set_chunkorder(uint32_t value);
  private:
  uint32_t _internal_chunkorder() const;
  void _internal_set_chunkorder(uint32_t value);
  public:

  // optional uint32 progress = 9;
  bool has_progress() const;
  private:
  bool _internal_has_progress() const;
  public:
  void clear_progress();
  uint32_t progress() const;
  void set_progress(uint32_t value);
  private:
  uint32_t _internal_progress() const;
  void _internal_set_progress(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.HistorySyncNotification)
 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 filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalmessageid_;
    uint64_t filelength_;
    int synctype_;
    uint32_t chunkorder_;
    uint32_t progress_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ImageMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ImageMessage) */ {
 public:
  inline Message_ImageMessage() : Message_ImageMessage(nullptr) {}
  ~Message_ImageMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ImageMessage(const Message_ImageMessage& from);
  Message_ImageMessage(Message_ImageMessage&& from) noexcept
    : Message_ImageMessage() {
    *this = ::std::move(from);
  }

  inline Message_ImageMessage& operator=(const Message_ImageMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ImageMessage& operator=(Message_ImageMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ImageMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ImageMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ImageMessage*>(
               &_Message_ImageMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    84;

  friend void swap(Message_ImageMessage& a, Message_ImageMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ImageMessage* 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(Message_ImageMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ImageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ImageMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ImageMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ImageMessage& from) {
    Message_ImageMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ImageMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ImageMessage";
  }
  protected:
  explicit Message_ImageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInteractiveAnnotationsFieldNumber = 10,
    kScanLengthsFieldNumber = 22,
    kUrlFieldNumber = 1,
    kMimetypeFieldNumber = 2,
    kCaptionFieldNumber = 3,
    kFileSha256FieldNumber = 4,
    kMediaKeyFieldNumber = 8,
    kFileEncSha256FieldNumber = 9,
    kDirectPathFieldNumber = 11,
    kJpegThumbnailFieldNumber = 16,
    kFirstScanSidecarFieldNumber = 18,
    kScansSidecarFieldNumber = 21,
    kMidQualityFileSha256FieldNumber = 23,
    kMidQualityFileEncSha256FieldNumber = 24,
    kThumbnailDirectPathFieldNumber = 26,
    kThumbnailSha256FieldNumber = 27,
    kThumbnailEncSha256FieldNumber = 28,
    kStaticUrlFieldNumber = 29,
    kContextInfoFieldNumber = 17,
    kFileLengthFieldNumber = 5,
    kHeightFieldNumber = 6,
    kWidthFieldNumber = 7,
    kMediaKeyTimestampFieldNumber = 12,
    kFirstScanLengthFieldNumber = 19,
    kExperimentGroupIdFieldNumber = 20,
    kViewOnceFieldNumber = 25,
  };
  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
  int interactiveannotations_size() const;
  private:
  int _internal_interactiveannotations_size() const;
  public:
  void clear_interactiveannotations();
  ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
      mutable_interactiveannotations();
  private:
  const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const;
  ::proto::InteractiveAnnotation* _internal_add_interactiveannotations();
  public:
  const ::proto::InteractiveAnnotation& interactiveannotations(int index) const;
  ::proto::InteractiveAnnotation* add_interactiveannotations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
      interactiveannotations() const;

  // repeated uint32 scanLengths = 22;
  int scanlengths_size() const;
  private:
  int _internal_scanlengths_size() const;
  public:
  void clear_scanlengths();
  private:
  uint32_t _internal_scanlengths(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_scanlengths() const;
  void _internal_add_scanlengths(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_scanlengths();
  public:
  uint32_t scanlengths(int index) const;
  void set_scanlengths(int index, uint32_t value);
  void add_scanlengths(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      scanlengths() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_scanlengths();

  // optional 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 mimetype = 2;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional string caption = 3;
  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 bytes fileSha256 = 4;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes mediaKey = 8;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional bytes fileEncSha256 = 9;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 11;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional bytes firstScanSidecar = 18;
  bool has_firstscansidecar() const;
  private:
  bool _internal_has_firstscansidecar() const;
  public:
  void clear_firstscansidecar();
  const std::string& firstscansidecar() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_firstscansidecar(ArgT0&& arg0, ArgT... args);
  std::string* mutable_firstscansidecar();
  PROTOBUF_NODISCARD std::string* release_firstscansidecar();
  void set_allocated_firstscansidecar(std::string* firstscansidecar);
  private:
  const std::string& _internal_firstscansidecar() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstscansidecar(const std::string& value);
  std::string* _internal_mutable_firstscansidecar();
  public:

  // optional bytes scansSidecar = 21;
  bool has_scanssidecar() const;
  private:
  bool _internal_has_scanssidecar() const;
  public:
  void clear_scanssidecar();
  const std::string& scanssidecar() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_scanssidecar(ArgT0&& arg0, ArgT... args);
  std::string* mutable_scanssidecar();
  PROTOBUF_NODISCARD std::string* release_scanssidecar();
  void set_allocated_scanssidecar(std::string* scanssidecar);
  private:
  const std::string& _internal_scanssidecar() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_scanssidecar(const std::string& value);
  std::string* _internal_mutable_scanssidecar();
  public:

  // optional bytes midQualityFileSha256 = 23;
  bool has_midqualityfilesha256() const;
  private:
  bool _internal_has_midqualityfilesha256() const;
  public:
  void clear_midqualityfilesha256();
  const std::string& midqualityfilesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_midqualityfilesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_midqualityfilesha256();
  PROTOBUF_NODISCARD std::string* release_midqualityfilesha256();
  void set_allocated_midqualityfilesha256(std::string* midqualityfilesha256);
  private:
  const std::string& _internal_midqualityfilesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfilesha256(const std::string& value);
  std::string* _internal_mutable_midqualityfilesha256();
  public:

  // optional bytes midQualityFileEncSha256 = 24;
  bool has_midqualityfileencsha256() const;
  private:
  bool _internal_has_midqualityfileencsha256() const;
  public:
  void clear_midqualityfileencsha256();
  const std::string& midqualityfileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_midqualityfileencsha256();
  PROTOBUF_NODISCARD std::string* release_midqualityfileencsha256();
  void set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256);
  private:
  const std::string& _internal_midqualityfileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_midqualityfileencsha256(const std::string& value);
  std::string* _internal_mutable_midqualityfileencsha256();
  public:

  // optional string thumbnailDirectPath = 26;
  bool has_thumbnaildirectpath() const;
  private:
  bool _internal_has_thumbnaildirectpath() const;
  public:
  void clear_thumbnaildirectpath();
  const std::string& thumbnaildirectpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnaildirectpath();
  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
  private:
  const std::string& _internal_thumbnaildirectpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
  std::string* _internal_mutable_thumbnaildirectpath();
  public:

  // optional bytes thumbnailSha256 = 27;
  bool has_thumbnailsha256() const;
  private:
  bool _internal_has_thumbnailsha256() const;
  public:
  void clear_thumbnailsha256();
  const std::string& thumbnailsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
  private:
  const std::string& _internal_thumbnailsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailsha256();
  public:

  // optional bytes thumbnailEncSha256 = 28;
  bool has_thumbnailencsha256() const;
  private:
  bool _internal_has_thumbnailencsha256() const;
  public:
  void clear_thumbnailencsha256();
  const std::string& thumbnailencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailencsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
  private:
  const std::string& _internal_thumbnailencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailencsha256();
  public:

  // optional string staticUrl = 29;
  bool has_staticurl() const;
  private:
  bool _internal_has_staticurl() const;
  public:
  void clear_staticurl();
  const std::string& staticurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_staticurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_staticurl();
  PROTOBUF_NODISCARD std::string* release_staticurl();
  void set_allocated_staticurl(std::string* staticurl);
  private:
  const std::string& _internal_staticurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value);
  std::string* _internal_mutable_staticurl();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint64 fileLength = 5;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional uint32 height = 6;
  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:

  // optional uint32 width = 7;
  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 int64 mediaKeyTimestamp = 12;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // optional uint32 firstScanLength = 19;
  bool has_firstscanlength() const;
  private:
  bool _internal_has_firstscanlength() const;
  public:
  void clear_firstscanlength();
  uint32_t firstscanlength() const;
  void set_firstscanlength(uint32_t value);
  private:
  uint32_t _internal_firstscanlength() const;
  void _internal_set_firstscanlength(uint32_t value);
  public:

  // optional uint32 experimentGroupId = 20;
  bool has_experimentgroupid() const;
  private:
  bool _internal_has_experimentgroupid() const;
  public:
  void clear_experimentgroupid();
  uint32_t experimentgroupid() const;
  void set_experimentgroupid(uint32_t value);
  private:
  uint32_t _internal_experimentgroupid() const;
  void _internal_set_experimentgroupid(uint32_t value);
  public:

  // optional bool viewOnce = 25;
  bool has_viewonce() const;
  private:
  bool _internal_has_viewonce() const;
  public:
  void clear_viewonce();
  bool viewonce() const;
  void set_viewonce(bool value);
  private:
  bool _internal_viewonce() const;
  void _internal_set_viewonce(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ImageMessage)
 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< ::proto::InteractiveAnnotation > interactiveannotations_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > scanlengths_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstscansidecar_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scanssidecar_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfilesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr midqualityfileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_;
    ::proto::ContextInfo* contextinfo_;
    uint64_t filelength_;
    uint32_t height_;
    uint32_t width_;
    int64_t mediakeytimestamp_;
    uint32_t firstscanlength_;
    uint32_t experimentgroupid_;
    bool viewonce_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InitialSecurityNotificationSettingSync final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InitialSecurityNotificationSettingSync) */ {
 public:
  inline Message_InitialSecurityNotificationSettingSync() : Message_InitialSecurityNotificationSettingSync(nullptr) {}
  ~Message_InitialSecurityNotificationSettingSync() override;
  explicit PROTOBUF_CONSTEXPR Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InitialSecurityNotificationSettingSync(const Message_InitialSecurityNotificationSettingSync& from);
  Message_InitialSecurityNotificationSettingSync(Message_InitialSecurityNotificationSettingSync&& from) noexcept
    : Message_InitialSecurityNotificationSettingSync() {
    *this = ::std::move(from);
  }

  inline Message_InitialSecurityNotificationSettingSync& operator=(const Message_InitialSecurityNotificationSettingSync& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InitialSecurityNotificationSettingSync& operator=(Message_InitialSecurityNotificationSettingSync&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InitialSecurityNotificationSettingSync& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InitialSecurityNotificationSettingSync* internal_default_instance() {
    return reinterpret_cast<const Message_InitialSecurityNotificationSettingSync*>(
               &_Message_InitialSecurityNotificationSettingSync_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    85;

  friend void swap(Message_InitialSecurityNotificationSettingSync& a, Message_InitialSecurityNotificationSettingSync& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InitialSecurityNotificationSettingSync* 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(Message_InitialSecurityNotificationSettingSync* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InitialSecurityNotificationSettingSync* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InitialSecurityNotificationSettingSync>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InitialSecurityNotificationSettingSync& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InitialSecurityNotificationSettingSync& from) {
    Message_InitialSecurityNotificationSettingSync::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InitialSecurityNotificationSettingSync* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InitialSecurityNotificationSettingSync";
  }
  protected:
  explicit Message_InitialSecurityNotificationSettingSync(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSecurityNotificationEnabledFieldNumber = 1,
  };
  // optional bool securityNotificationEnabled = 1;
  bool has_securitynotificationenabled() const;
  private:
  bool _internal_has_securitynotificationenabled() const;
  public:
  void clear_securitynotificationenabled();
  bool securitynotificationenabled() const;
  void set_securitynotificationenabled(bool value);
  private:
  bool _internal_securitynotificationenabled() const;
  void _internal_set_securitynotificationenabled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InitialSecurityNotificationSettingSync)
 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 securitynotificationenabled_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_Body final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Body) */ {
 public:
  inline Message_InteractiveMessage_Body() : Message_InteractiveMessage_Body(nullptr) {}
  ~Message_InteractiveMessage_Body() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_Body(const Message_InteractiveMessage_Body& from);
  Message_InteractiveMessage_Body(Message_InteractiveMessage_Body&& from) noexcept
    : Message_InteractiveMessage_Body() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_Body& operator=(const Message_InteractiveMessage_Body& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_Body& operator=(Message_InteractiveMessage_Body&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_Body& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_Body* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_Body*>(
               &_Message_InteractiveMessage_Body_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    86;

  friend void swap(Message_InteractiveMessage_Body& a, Message_InteractiveMessage_Body& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_Body* 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(Message_InteractiveMessage_Body* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_Body>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_Body& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_Body& from) {
    Message_InteractiveMessage_Body::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_Body* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.Body";
  }
  protected:
  explicit Message_InteractiveMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 1,
  };
  // optional string text = 1;
  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:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Body)
 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 text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_CollectionMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.CollectionMessage) */ {
 public:
  inline Message_InteractiveMessage_CollectionMessage() : Message_InteractiveMessage_CollectionMessage(nullptr) {}
  ~Message_InteractiveMessage_CollectionMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_CollectionMessage(const Message_InteractiveMessage_CollectionMessage& from);
  Message_InteractiveMessage_CollectionMessage(Message_InteractiveMessage_CollectionMessage&& from) noexcept
    : Message_InteractiveMessage_CollectionMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_CollectionMessage& operator=(const Message_InteractiveMessage_CollectionMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_CollectionMessage& operator=(Message_InteractiveMessage_CollectionMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_CollectionMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_CollectionMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_CollectionMessage*>(
               &_Message_InteractiveMessage_CollectionMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    87;

  friend void swap(Message_InteractiveMessage_CollectionMessage& a, Message_InteractiveMessage_CollectionMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_CollectionMessage* 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(Message_InteractiveMessage_CollectionMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_CollectionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_CollectionMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_CollectionMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_CollectionMessage& from) {
    Message_InteractiveMessage_CollectionMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_CollectionMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.CollectionMessage";
  }
  protected:
  explicit Message_InteractiveMessage_CollectionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBizJidFieldNumber = 1,
    kIdFieldNumber = 2,
    kMessageVersionFieldNumber = 3,
  };
  // optional string bizJid = 1;
  bool has_bizjid() const;
  private:
  bool _internal_has_bizjid() const;
  public:
  void clear_bizjid();
  const std::string& bizjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_bizjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_bizjid();
  PROTOBUF_NODISCARD std::string* release_bizjid();
  void set_allocated_bizjid(std::string* bizjid);
  private:
  const std::string& _internal_bizjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_bizjid(const std::string& value);
  std::string* _internal_mutable_bizjid();
  public:

  // optional string id = 2;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional int32 messageVersion = 3;
  bool has_messageversion() const;
  private:
  bool _internal_has_messageversion() const;
  public:
  void clear_messageversion();
  int32_t messageversion() const;
  void set_messageversion(int32_t value);
  private:
  int32_t _internal_messageversion() const;
  void _internal_set_messageversion(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.CollectionMessage)
 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 bizjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
    int32_t messageversion_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_Footer final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Footer) */ {
 public:
  inline Message_InteractiveMessage_Footer() : Message_InteractiveMessage_Footer(nullptr) {}
  ~Message_InteractiveMessage_Footer() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_Footer(const Message_InteractiveMessage_Footer& from);
  Message_InteractiveMessage_Footer(Message_InteractiveMessage_Footer&& from) noexcept
    : Message_InteractiveMessage_Footer() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_Footer& operator=(const Message_InteractiveMessage_Footer& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_Footer& operator=(Message_InteractiveMessage_Footer&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_Footer& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_Footer* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_Footer*>(
               &_Message_InteractiveMessage_Footer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    88;

  friend void swap(Message_InteractiveMessage_Footer& a, Message_InteractiveMessage_Footer& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_Footer* 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(Message_InteractiveMessage_Footer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_Footer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_Footer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_Footer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_Footer& from) {
    Message_InteractiveMessage_Footer::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_Footer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.Footer";
  }
  protected:
  explicit Message_InteractiveMessage_Footer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 1,
  };
  // optional string text = 1;
  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:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Footer)
 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 text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_Header final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.Header) */ {
 public:
  inline Message_InteractiveMessage_Header() : Message_InteractiveMessage_Header(nullptr) {}
  ~Message_InteractiveMessage_Header() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_Header(const Message_InteractiveMessage_Header& from);
  Message_InteractiveMessage_Header(Message_InteractiveMessage_Header&& from) noexcept
    : Message_InteractiveMessage_Header() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_Header& operator=(const Message_InteractiveMessage_Header& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_Header& operator=(Message_InteractiveMessage_Header&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_Header& default_instance() {
    return *internal_default_instance();
  }
  enum MediaCase {
    kDocumentMessage = 3,
    kImageMessage = 4,
    kJpegThumbnail = 6,
    kVideoMessage = 7,
    MEDIA_NOT_SET = 0,
  };

  static inline const Message_InteractiveMessage_Header* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_Header*>(
               &_Message_InteractiveMessage_Header_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    89;

  friend void swap(Message_InteractiveMessage_Header& a, Message_InteractiveMessage_Header& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_Header* 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(Message_InteractiveMessage_Header* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_Header>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_Header& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_Header& from) {
    Message_InteractiveMessage_Header::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_Header* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.Header";
  }
  protected:
  explicit Message_InteractiveMessage_Header(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTitleFieldNumber = 1,
    kSubtitleFieldNumber = 2,
    kHasMediaAttachmentFieldNumber = 5,
    kDocumentMessageFieldNumber = 3,
    kImageMessageFieldNumber = 4,
    kJpegThumbnailFieldNumber = 6,
    kVideoMessageFieldNumber = 7,
  };
  // optional string title = 1;
  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 string subtitle = 2;
  bool has_subtitle() const;
  private:
  bool _internal_has_subtitle() const;
  public:
  void clear_subtitle();
  const std::string& subtitle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_subtitle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_subtitle();
  PROTOBUF_NODISCARD std::string* release_subtitle();
  void set_allocated_subtitle(std::string* subtitle);
  private:
  const std::string& _internal_subtitle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subtitle(const std::string& value);
  std::string* _internal_mutable_subtitle();
  public:

  // optional bool hasMediaAttachment = 5;
  bool has_hasmediaattachment() const;
  private:
  bool _internal_has_hasmediaattachment() const;
  public:
  void clear_hasmediaattachment();
  bool hasmediaattachment() const;
  void set_hasmediaattachment(bool value);
  private:
  bool _internal_hasmediaattachment() const;
  void _internal_set_hasmediaattachment(bool value);
  public:

  // .proto.Message.DocumentMessage documentMessage = 3;
  bool has_documentmessage() const;
  private:
  bool _internal_has_documentmessage() const;
  public:
  void clear_documentmessage();
  const ::proto::Message_DocumentMessage& documentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
  ::proto::Message_DocumentMessage* mutable_documentmessage();
  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
  private:
  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
  public:
  void unsafe_arena_set_allocated_documentmessage(
      ::proto::Message_DocumentMessage* documentmessage);
  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();

  // .proto.Message.ImageMessage imageMessage = 4;
  bool has_imagemessage() const;
  private:
  bool _internal_has_imagemessage() const;
  public:
  void clear_imagemessage();
  const ::proto::Message_ImageMessage& imagemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
  ::proto::Message_ImageMessage* mutable_imagemessage();
  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
  private:
  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
  public:
  void unsafe_arena_set_allocated_imagemessage(
      ::proto::Message_ImageMessage* imagemessage);
  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();

  // bytes jpegThumbnail = 6;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // .proto.Message.VideoMessage videoMessage = 7;
  bool has_videomessage() const;
  private:
  bool _internal_has_videomessage() const;
  public:
  void clear_videomessage();
  const ::proto::Message_VideoMessage& videomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
  ::proto::Message_VideoMessage* mutable_videomessage();
  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
  private:
  const ::proto::Message_VideoMessage& _internal_videomessage() const;
  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
  public:
  void unsafe_arena_set_allocated_videomessage(
      ::proto::Message_VideoMessage* videomessage);
  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();

  void clear_media();
  MediaCase media_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.Header)
 private:
  class _Internal;
  void set_has_documentmessage();
  void set_has_imagemessage();
  void set_has_jpegthumbnail();
  void set_has_videomessage();

  inline bool has_media() const;
  inline void clear_has_media();

  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 title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subtitle_;
    bool hasmediaattachment_;
    union MediaUnion {
      constexpr MediaUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_DocumentMessage* documentmessage_;
      ::proto::Message_ImageMessage* imagemessage_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
      ::proto::Message_VideoMessage* videomessage_;
    } media_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton) */ {
 public:
  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(nullptr) {}
  ~Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from);
  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept
    : Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& operator=(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton*>(
               &_Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    90;

  friend void swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& a, Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* 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(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& from) {
    Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton";
  }
  protected:
  explicit Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kButtonParamsJsonFieldNumber = 2,
  };
  // optional string name = 1;
  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:

  // optional string buttonParamsJson = 2;
  bool has_buttonparamsjson() const;
  private:
  bool _internal_has_buttonparamsjson() const;
  public:
  void clear_buttonparamsjson();
  const std::string& buttonparamsjson() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_buttonparamsjson(ArgT0&& arg0, ArgT... args);
  std::string* mutable_buttonparamsjson();
  PROTOBUF_NODISCARD std::string* release_buttonparamsjson();
  void set_allocated_buttonparamsjson(std::string* buttonparamsjson);
  private:
  const std::string& _internal_buttonparamsjson() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttonparamsjson(const std::string& value);
  std::string* _internal_mutable_buttonparamsjson();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton)
 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 name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttonparamsjson_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_NativeFlowMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.NativeFlowMessage) */ {
 public:
  inline Message_InteractiveMessage_NativeFlowMessage() : Message_InteractiveMessage_NativeFlowMessage(nullptr) {}
  ~Message_InteractiveMessage_NativeFlowMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_NativeFlowMessage(const Message_InteractiveMessage_NativeFlowMessage& from);
  Message_InteractiveMessage_NativeFlowMessage(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept
    : Message_InteractiveMessage_NativeFlowMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_NativeFlowMessage& operator=(const Message_InteractiveMessage_NativeFlowMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_NativeFlowMessage& operator=(Message_InteractiveMessage_NativeFlowMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_NativeFlowMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_NativeFlowMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_NativeFlowMessage*>(
               &_Message_InteractiveMessage_NativeFlowMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    91;

  friend void swap(Message_InteractiveMessage_NativeFlowMessage& a, Message_InteractiveMessage_NativeFlowMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_NativeFlowMessage* 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(Message_InteractiveMessage_NativeFlowMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_NativeFlowMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_NativeFlowMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_NativeFlowMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_NativeFlowMessage& from) {
    Message_InteractiveMessage_NativeFlowMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_NativeFlowMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.NativeFlowMessage";
  }
  protected:
  explicit Message_InteractiveMessage_NativeFlowMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton NativeFlowButton;

  // accessors -------------------------------------------------------

  enum : int {
    kButtonsFieldNumber = 1,
    kMessageParamsJsonFieldNumber = 2,
    kMessageVersionFieldNumber = 3,
  };
  // repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
  int buttons_size() const;
  private:
  int _internal_buttons_size() const;
  public:
  void clear_buttons();
  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* mutable_buttons(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >*
      mutable_buttons();
  private:
  const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& _internal_buttons(int index) const;
  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _internal_add_buttons();
  public:
  const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& buttons(int index) const;
  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* add_buttons();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >&
      buttons() const;

  // optional string messageParamsJson = 2;
  bool has_messageparamsjson() const;
  private:
  bool _internal_has_messageparamsjson() const;
  public:
  void clear_messageparamsjson();
  const std::string& messageparamsjson() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_messageparamsjson(ArgT0&& arg0, ArgT... args);
  std::string* mutable_messageparamsjson();
  PROTOBUF_NODISCARD std::string* release_messageparamsjson();
  void set_allocated_messageparamsjson(std::string* messageparamsjson);
  private:
  const std::string& _internal_messageparamsjson() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messageparamsjson(const std::string& value);
  std::string* _internal_mutable_messageparamsjson();
  public:

  // optional int32 messageVersion = 3;
  bool has_messageversion() const;
  private:
  bool _internal_has_messageversion() const;
  public:
  void clear_messageversion();
  int32_t messageversion() const;
  void set_messageversion(int32_t value);
  private:
  int32_t _internal_messageversion() const;
  void _internal_set_messageversion(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.NativeFlowMessage)
 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< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton > buttons_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messageparamsjson_;
    int32_t messageversion_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage_ShopMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage.ShopMessage) */ {
 public:
  inline Message_InteractiveMessage_ShopMessage() : Message_InteractiveMessage_ShopMessage(nullptr) {}
  ~Message_InteractiveMessage_ShopMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage_ShopMessage(const Message_InteractiveMessage_ShopMessage& from);
  Message_InteractiveMessage_ShopMessage(Message_InteractiveMessage_ShopMessage&& from) noexcept
    : Message_InteractiveMessage_ShopMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage_ShopMessage& operator=(const Message_InteractiveMessage_ShopMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage_ShopMessage& operator=(Message_InteractiveMessage_ShopMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage_ShopMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveMessage_ShopMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage_ShopMessage*>(
               &_Message_InteractiveMessage_ShopMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    92;

  friend void swap(Message_InteractiveMessage_ShopMessage& a, Message_InteractiveMessage_ShopMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage_ShopMessage* 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(Message_InteractiveMessage_ShopMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage_ShopMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage_ShopMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage_ShopMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage_ShopMessage& from) {
    Message_InteractiveMessage_ShopMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage_ShopMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage.ShopMessage";
  }
  protected:
  explicit Message_InteractiveMessage_ShopMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_InteractiveMessage_ShopMessage_Surface Surface;
  static constexpr Surface UNKNOWN_SURFACE =
    Message_InteractiveMessage_ShopMessage_Surface_UNKNOWN_SURFACE;
  static constexpr Surface FB =
    Message_InteractiveMessage_ShopMessage_Surface_FB;
  static constexpr Surface IG =
    Message_InteractiveMessage_ShopMessage_Surface_IG;
  static constexpr Surface WA =
    Message_InteractiveMessage_ShopMessage_Surface_WA;
  static inline bool Surface_IsValid(int value) {
    return Message_InteractiveMessage_ShopMessage_Surface_IsValid(value);
  }
  static constexpr Surface Surface_MIN =
    Message_InteractiveMessage_ShopMessage_Surface_Surface_MIN;
  static constexpr Surface Surface_MAX =
    Message_InteractiveMessage_ShopMessage_Surface_Surface_MAX;
  static constexpr int Surface_ARRAYSIZE =
    Message_InteractiveMessage_ShopMessage_Surface_Surface_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Surface_descriptor() {
    return Message_InteractiveMessage_ShopMessage_Surface_descriptor();
  }
  template<typename T>
  static inline const std::string& Surface_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Surface>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Surface_Name.");
    return Message_InteractiveMessage_ShopMessage_Surface_Name(enum_t_value);
  }
  static inline bool Surface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Surface* value) {
    return Message_InteractiveMessage_ShopMessage_Surface_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 1,
    kSurfaceFieldNumber = 2,
    kMessageVersionFieldNumber = 3,
  };
  // optional string id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
  bool has_surface() const;
  private:
  bool _internal_has_surface() const;
  public:
  void clear_surface();
  ::proto::Message_InteractiveMessage_ShopMessage_Surface surface() const;
  void set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value);
  private:
  ::proto::Message_InteractiveMessage_ShopMessage_Surface _internal_surface() const;
  void _internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value);
  public:

  // optional int32 messageVersion = 3;
  bool has_messageversion() const;
  private:
  bool _internal_has_messageversion() const;
  public:
  void clear_messageversion();
  int32_t messageversion() const;
  void set_messageversion(int32_t value);
  private:
  int32_t _internal_messageversion() const;
  void _internal_set_messageversion(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage.ShopMessage)
 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 id_;
    int surface_;
    int32_t messageversion_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveMessage) */ {
 public:
  inline Message_InteractiveMessage() : Message_InteractiveMessage(nullptr) {}
  ~Message_InteractiveMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveMessage(const Message_InteractiveMessage& from);
  Message_InteractiveMessage(Message_InteractiveMessage&& from) noexcept
    : Message_InteractiveMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveMessage& operator=(const Message_InteractiveMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveMessage& operator=(Message_InteractiveMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveMessage& default_instance() {
    return *internal_default_instance();
  }
  enum InteractiveMessageCase {
    kShopStorefrontMessage = 4,
    kCollectionMessage = 5,
    kNativeFlowMessage = 6,
    INTERACTIVEMESSAGE_NOT_SET = 0,
  };

  static inline const Message_InteractiveMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveMessage*>(
               &_Message_InteractiveMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    93;

  friend void swap(Message_InteractiveMessage& a, Message_InteractiveMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveMessage* 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(Message_InteractiveMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveMessage& from) {
    Message_InteractiveMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveMessage";
  }
  protected:
  explicit Message_InteractiveMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_InteractiveMessage_Body Body;
  typedef Message_InteractiveMessage_CollectionMessage CollectionMessage;
  typedef Message_InteractiveMessage_Footer Footer;
  typedef Message_InteractiveMessage_Header Header;
  typedef Message_InteractiveMessage_NativeFlowMessage NativeFlowMessage;
  typedef Message_InteractiveMessage_ShopMessage ShopMessage;

  // accessors -------------------------------------------------------

  enum : int {
    kHeaderFieldNumber = 1,
    kBodyFieldNumber = 2,
    kFooterFieldNumber = 3,
    kContextInfoFieldNumber = 15,
    kShopStorefrontMessageFieldNumber = 4,
    kCollectionMessageFieldNumber = 5,
    kNativeFlowMessageFieldNumber = 6,
  };
  // optional .proto.Message.InteractiveMessage.Header header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::proto::Message_InteractiveMessage_Header& header() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Header* release_header();
  ::proto::Message_InteractiveMessage_Header* mutable_header();
  void set_allocated_header(::proto::Message_InteractiveMessage_Header* header);
  private:
  const ::proto::Message_InteractiveMessage_Header& _internal_header() const;
  ::proto::Message_InteractiveMessage_Header* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::proto::Message_InteractiveMessage_Header* header);
  ::proto::Message_InteractiveMessage_Header* unsafe_arena_release_header();

  // optional .proto.Message.InteractiveMessage.Body body = 2;
  bool has_body() const;
  private:
  bool _internal_has_body() const;
  public:
  void clear_body();
  const ::proto::Message_InteractiveMessage_Body& body() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Body* release_body();
  ::proto::Message_InteractiveMessage_Body* mutable_body();
  void set_allocated_body(::proto::Message_InteractiveMessage_Body* body);
  private:
  const ::proto::Message_InteractiveMessage_Body& _internal_body() const;
  ::proto::Message_InteractiveMessage_Body* _internal_mutable_body();
  public:
  void unsafe_arena_set_allocated_body(
      ::proto::Message_InteractiveMessage_Body* body);
  ::proto::Message_InteractiveMessage_Body* unsafe_arena_release_body();

  // optional .proto.Message.InteractiveMessage.Footer footer = 3;
  bool has_footer() const;
  private:
  bool _internal_has_footer() const;
  public:
  void clear_footer();
  const ::proto::Message_InteractiveMessage_Footer& footer() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_Footer* release_footer();
  ::proto::Message_InteractiveMessage_Footer* mutable_footer();
  void set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer);
  private:
  const ::proto::Message_InteractiveMessage_Footer& _internal_footer() const;
  ::proto::Message_InteractiveMessage_Footer* _internal_mutable_footer();
  public:
  void unsafe_arena_set_allocated_footer(
      ::proto::Message_InteractiveMessage_Footer* footer);
  ::proto::Message_InteractiveMessage_Footer* unsafe_arena_release_footer();

  // optional .proto.ContextInfo contextInfo = 15;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
  bool has_shopstorefrontmessage() const;
  private:
  bool _internal_has_shopstorefrontmessage() const;
  public:
  void clear_shopstorefrontmessage();
  const ::proto::Message_InteractiveMessage_ShopMessage& shopstorefrontmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_ShopMessage* release_shopstorefrontmessage();
  ::proto::Message_InteractiveMessage_ShopMessage* mutable_shopstorefrontmessage();
  void set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage);
  private:
  const ::proto::Message_InteractiveMessage_ShopMessage& _internal_shopstorefrontmessage() const;
  ::proto::Message_InteractiveMessage_ShopMessage* _internal_mutable_shopstorefrontmessage();
  public:
  void unsafe_arena_set_allocated_shopstorefrontmessage(
      ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage);
  ::proto::Message_InteractiveMessage_ShopMessage* unsafe_arena_release_shopstorefrontmessage();

  // .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
  bool has_collectionmessage() const;
  private:
  bool _internal_has_collectionmessage() const;
  public:
  void clear_collectionmessage();
  const ::proto::Message_InteractiveMessage_CollectionMessage& collectionmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_CollectionMessage* release_collectionmessage();
  ::proto::Message_InteractiveMessage_CollectionMessage* mutable_collectionmessage();
  void set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage);
  private:
  const ::proto::Message_InteractiveMessage_CollectionMessage& _internal_collectionmessage() const;
  ::proto::Message_InteractiveMessage_CollectionMessage* _internal_mutable_collectionmessage();
  public:
  void unsafe_arena_set_allocated_collectionmessage(
      ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage);
  ::proto::Message_InteractiveMessage_CollectionMessage* unsafe_arena_release_collectionmessage();

  // .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
  bool has_nativeflowmessage() const;
  private:
  bool _internal_has_nativeflowmessage() const;
  public:
  void clear_nativeflowmessage();
  const ::proto::Message_InteractiveMessage_NativeFlowMessage& nativeflowmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage_NativeFlowMessage* release_nativeflowmessage();
  ::proto::Message_InteractiveMessage_NativeFlowMessage* mutable_nativeflowmessage();
  void set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage);
  private:
  const ::proto::Message_InteractiveMessage_NativeFlowMessage& _internal_nativeflowmessage() const;
  ::proto::Message_InteractiveMessage_NativeFlowMessage* _internal_mutable_nativeflowmessage();
  public:
  void unsafe_arena_set_allocated_nativeflowmessage(
      ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage);
  ::proto::Message_InteractiveMessage_NativeFlowMessage* unsafe_arena_release_nativeflowmessage();

  void clear_interactiveMessage();
  InteractiveMessageCase interactiveMessage_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveMessage)
 private:
  class _Internal;
  void set_has_shopstorefrontmessage();
  void set_has_collectionmessage();
  void set_has_nativeflowmessage();

  inline bool has_interactiveMessage() const;
  inline void clear_has_interactiveMessage();

  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_;
    ::proto::Message_InteractiveMessage_Header* header_;
    ::proto::Message_InteractiveMessage_Body* body_;
    ::proto::Message_InteractiveMessage_Footer* footer_;
    ::proto::ContextInfo* contextinfo_;
    union InteractiveMessageUnion {
      constexpr InteractiveMessageUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage_;
      ::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage_;
      ::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage_;
    } interactiveMessage_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveResponseMessage_Body final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.Body) */ {
 public:
  inline Message_InteractiveResponseMessage_Body() : Message_InteractiveResponseMessage_Body(nullptr) {}
  ~Message_InteractiveResponseMessage_Body() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveResponseMessage_Body(const Message_InteractiveResponseMessage_Body& from);
  Message_InteractiveResponseMessage_Body(Message_InteractiveResponseMessage_Body&& from) noexcept
    : Message_InteractiveResponseMessage_Body() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveResponseMessage_Body& operator=(const Message_InteractiveResponseMessage_Body& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveResponseMessage_Body& operator=(Message_InteractiveResponseMessage_Body&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveResponseMessage_Body& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveResponseMessage_Body* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveResponseMessage_Body*>(
               &_Message_InteractiveResponseMessage_Body_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    94;

  friend void swap(Message_InteractiveResponseMessage_Body& a, Message_InteractiveResponseMessage_Body& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveResponseMessage_Body* 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(Message_InteractiveResponseMessage_Body* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveResponseMessage_Body* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveResponseMessage_Body>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveResponseMessage_Body& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveResponseMessage_Body& from) {
    Message_InteractiveResponseMessage_Body::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveResponseMessage_Body* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveResponseMessage.Body";
  }
  protected:
  explicit Message_InteractiveResponseMessage_Body(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 1,
  };
  // optional string text = 1;
  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:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.Body)
 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 text_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveResponseMessage_NativeFlowResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage) */ {
 public:
  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage() : Message_InteractiveResponseMessage_NativeFlowResponseMessage(nullptr) {}
  ~Message_InteractiveResponseMessage_NativeFlowResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveResponseMessage_NativeFlowResponseMessage(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from);
  Message_InteractiveResponseMessage_NativeFlowResponseMessage(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept
    : Message_InteractiveResponseMessage_NativeFlowResponseMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveResponseMessage_NativeFlowResponseMessage& operator=(Message_InteractiveResponseMessage_NativeFlowResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveResponseMessage_NativeFlowResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InteractiveResponseMessage_NativeFlowResponseMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveResponseMessage_NativeFlowResponseMessage*>(
               &_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    95;

  friend void swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage& a, Message_InteractiveResponseMessage_NativeFlowResponseMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* 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(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveResponseMessage_NativeFlowResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveResponseMessage_NativeFlowResponseMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveResponseMessage_NativeFlowResponseMessage& from) {
    Message_InteractiveResponseMessage_NativeFlowResponseMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveResponseMessage_NativeFlowResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage";
  }
  protected:
  explicit Message_InteractiveResponseMessage_NativeFlowResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kParamsJsonFieldNumber = 2,
    kVersionFieldNumber = 3,
  };
  // optional string name = 1;
  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:

  // optional string paramsJson = 2;
  bool has_paramsjson() const;
  private:
  bool _internal_has_paramsjson() const;
  public:
  void clear_paramsjson();
  const std::string& paramsjson() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_paramsjson(ArgT0&& arg0, ArgT... args);
  std::string* mutable_paramsjson();
  PROTOBUF_NODISCARD std::string* release_paramsjson();
  void set_allocated_paramsjson(std::string* paramsjson);
  private:
  const std::string& _internal_paramsjson() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paramsjson(const std::string& value);
  std::string* _internal_mutable_paramsjson();
  public:

  // optional int32 version = 3;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage)
 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 name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paramsjson_;
    int32_t version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InteractiveResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InteractiveResponseMessage) */ {
 public:
  inline Message_InteractiveResponseMessage() : Message_InteractiveResponseMessage(nullptr) {}
  ~Message_InteractiveResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InteractiveResponseMessage(const Message_InteractiveResponseMessage& from);
  Message_InteractiveResponseMessage(Message_InteractiveResponseMessage&& from) noexcept
    : Message_InteractiveResponseMessage() {
    *this = ::std::move(from);
  }

  inline Message_InteractiveResponseMessage& operator=(const Message_InteractiveResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InteractiveResponseMessage& operator=(Message_InteractiveResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InteractiveResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  enum InteractiveResponseMessageCase {
    kNativeFlowResponseMessage = 2,
    INTERACTIVERESPONSEMESSAGE_NOT_SET = 0,
  };

  static inline const Message_InteractiveResponseMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InteractiveResponseMessage*>(
               &_Message_InteractiveResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    96;

  friend void swap(Message_InteractiveResponseMessage& a, Message_InteractiveResponseMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InteractiveResponseMessage* 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(Message_InteractiveResponseMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InteractiveResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InteractiveResponseMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InteractiveResponseMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InteractiveResponseMessage& from) {
    Message_InteractiveResponseMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InteractiveResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InteractiveResponseMessage";
  }
  protected:
  explicit Message_InteractiveResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_InteractiveResponseMessage_Body Body;
  typedef Message_InteractiveResponseMessage_NativeFlowResponseMessage NativeFlowResponseMessage;

  // accessors -------------------------------------------------------

  enum : int {
    kBodyFieldNumber = 1,
    kContextInfoFieldNumber = 15,
    kNativeFlowResponseMessageFieldNumber = 2,
  };
  // optional .proto.Message.InteractiveResponseMessage.Body body = 1;
  bool has_body() const;
  private:
  bool _internal_has_body() const;
  public:
  void clear_body();
  const ::proto::Message_InteractiveResponseMessage_Body& body() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_Body* release_body();
  ::proto::Message_InteractiveResponseMessage_Body* mutable_body();
  void set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body);
  private:
  const ::proto::Message_InteractiveResponseMessage_Body& _internal_body() const;
  ::proto::Message_InteractiveResponseMessage_Body* _internal_mutable_body();
  public:
  void unsafe_arena_set_allocated_body(
      ::proto::Message_InteractiveResponseMessage_Body* body);
  ::proto::Message_InteractiveResponseMessage_Body* unsafe_arena_release_body();

  // optional .proto.ContextInfo contextInfo = 15;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
  bool has_nativeflowresponsemessage() const;
  private:
  bool _internal_has_nativeflowresponsemessage() const;
  public:
  void clear_nativeflowresponsemessage();
  const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& nativeflowresponsemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* release_nativeflowresponsemessage();
  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* mutable_nativeflowresponsemessage();
  void set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage);
  private:
  const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& _internal_nativeflowresponsemessage() const;
  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _internal_mutable_nativeflowresponsemessage();
  public:
  void unsafe_arena_set_allocated_nativeflowresponsemessage(
      ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage);
  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* unsafe_arena_release_nativeflowresponsemessage();

  void clear_interactiveResponseMessage();
  InteractiveResponseMessageCase interactiveResponseMessage_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.InteractiveResponseMessage)
 private:
  class _Internal;
  void set_has_nativeflowresponsemessage();

  inline bool has_interactiveResponseMessage() const;
  inline void clear_has_interactiveResponseMessage();

  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_;
    ::proto::Message_InteractiveResponseMessage_Body* body_;
    ::proto::ContextInfo* contextinfo_;
    union InteractiveResponseMessageUnion {
      constexpr InteractiveResponseMessageUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage_;
    } interactiveResponseMessage_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_InvoiceMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.InvoiceMessage) */ {
 public:
  inline Message_InvoiceMessage() : Message_InvoiceMessage(nullptr) {}
  ~Message_InvoiceMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_InvoiceMessage(const Message_InvoiceMessage& from);
  Message_InvoiceMessage(Message_InvoiceMessage&& from) noexcept
    : Message_InvoiceMessage() {
    *this = ::std::move(from);
  }

  inline Message_InvoiceMessage& operator=(const Message_InvoiceMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_InvoiceMessage& operator=(Message_InvoiceMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_InvoiceMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_InvoiceMessage* internal_default_instance() {
    return reinterpret_cast<const Message_InvoiceMessage*>(
               &_Message_InvoiceMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    97;

  friend void swap(Message_InvoiceMessage& a, Message_InvoiceMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_InvoiceMessage* 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(Message_InvoiceMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_InvoiceMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_InvoiceMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_InvoiceMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_InvoiceMessage& from) {
    Message_InvoiceMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_InvoiceMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.InvoiceMessage";
  }
  protected:
  explicit Message_InvoiceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_InvoiceMessage_AttachmentType AttachmentType;
  static constexpr AttachmentType IMAGE =
    Message_InvoiceMessage_AttachmentType_IMAGE;
  static constexpr AttachmentType PDF =
    Message_InvoiceMessage_AttachmentType_PDF;
  static inline bool AttachmentType_IsValid(int value) {
    return Message_InvoiceMessage_AttachmentType_IsValid(value);
  }
  static constexpr AttachmentType AttachmentType_MIN =
    Message_InvoiceMessage_AttachmentType_AttachmentType_MIN;
  static constexpr AttachmentType AttachmentType_MAX =
    Message_InvoiceMessage_AttachmentType_AttachmentType_MAX;
  static constexpr int AttachmentType_ARRAYSIZE =
    Message_InvoiceMessage_AttachmentType_AttachmentType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  AttachmentType_descriptor() {
    return Message_InvoiceMessage_AttachmentType_descriptor();
  }
  template<typename T>
  static inline const std::string& AttachmentType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, AttachmentType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function AttachmentType_Name.");
    return Message_InvoiceMessage_AttachmentType_Name(enum_t_value);
  }
  static inline bool AttachmentType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      AttachmentType* value) {
    return Message_InvoiceMessage_AttachmentType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kNoteFieldNumber = 1,
    kTokenFieldNumber = 2,
    kAttachmentMimetypeFieldNumber = 4,
    kAttachmentMediaKeyFieldNumber = 5,
    kAttachmentFileSha256FieldNumber = 7,
    kAttachmentFileEncSha256FieldNumber = 8,
    kAttachmentDirectPathFieldNumber = 9,
    kAttachmentJpegThumbnailFieldNumber = 10,
    kAttachmentMediaKeyTimestampFieldNumber = 6,
    kAttachmentTypeFieldNumber = 3,
  };
  // optional string note = 1;
  bool has_note() const;
  private:
  bool _internal_has_note() const;
  public:
  void clear_note();
  const std::string& note() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_note(ArgT0&& arg0, ArgT... args);
  std::string* mutable_note();
  PROTOBUF_NODISCARD std::string* release_note();
  void set_allocated_note(std::string* note);
  private:
  const std::string& _internal_note() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_note(const std::string& value);
  std::string* _internal_mutable_note();
  public:

  // optional string token = 2;
  bool has_token() const;
  private:
  bool _internal_has_token() const;
  public:
  void clear_token();
  const std::string& token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_token();
  PROTOBUF_NODISCARD std::string* release_token();
  void set_allocated_token(std::string* token);
  private:
  const std::string& _internal_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
  std::string* _internal_mutable_token();
  public:

  // optional string attachmentMimetype = 4;
  bool has_attachmentmimetype() const;
  private:
  bool _internal_has_attachmentmimetype() const;
  public:
  void clear_attachmentmimetype();
  const std::string& attachmentmimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentmimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentmimetype();
  PROTOBUF_NODISCARD std::string* release_attachmentmimetype();
  void set_allocated_attachmentmimetype(std::string* attachmentmimetype);
  private:
  const std::string& _internal_attachmentmimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmimetype(const std::string& value);
  std::string* _internal_mutable_attachmentmimetype();
  public:

  // optional bytes attachmentMediaKey = 5;
  bool has_attachmentmediakey() const;
  private:
  bool _internal_has_attachmentmediakey() const;
  public:
  void clear_attachmentmediakey();
  const std::string& attachmentmediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentmediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentmediakey();
  PROTOBUF_NODISCARD std::string* release_attachmentmediakey();
  void set_allocated_attachmentmediakey(std::string* attachmentmediakey);
  private:
  const std::string& _internal_attachmentmediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentmediakey(const std::string& value);
  std::string* _internal_mutable_attachmentmediakey();
  public:

  // optional bytes attachmentFileSha256 = 7;
  bool has_attachmentfilesha256() const;
  private:
  bool _internal_has_attachmentfilesha256() const;
  public:
  void clear_attachmentfilesha256();
  const std::string& attachmentfilesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentfilesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentfilesha256();
  PROTOBUF_NODISCARD std::string* release_attachmentfilesha256();
  void set_allocated_attachmentfilesha256(std::string* attachmentfilesha256);
  private:
  const std::string& _internal_attachmentfilesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfilesha256(const std::string& value);
  std::string* _internal_mutable_attachmentfilesha256();
  public:

  // optional bytes attachmentFileEncSha256 = 8;
  bool has_attachmentfileencsha256() const;
  private:
  bool _internal_has_attachmentfileencsha256() const;
  public:
  void clear_attachmentfileencsha256();
  const std::string& attachmentfileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentfileencsha256();
  PROTOBUF_NODISCARD std::string* release_attachmentfileencsha256();
  void set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256);
  private:
  const std::string& _internal_attachmentfileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentfileencsha256(const std::string& value);
  std::string* _internal_mutable_attachmentfileencsha256();
  public:

  // optional string attachmentDirectPath = 9;
  bool has_attachmentdirectpath() const;
  private:
  bool _internal_has_attachmentdirectpath() const;
  public:
  void clear_attachmentdirectpath();
  const std::string& attachmentdirectpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentdirectpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentdirectpath();
  PROTOBUF_NODISCARD std::string* release_attachmentdirectpath();
  void set_allocated_attachmentdirectpath(std::string* attachmentdirectpath);
  private:
  const std::string& _internal_attachmentdirectpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentdirectpath(const std::string& value);
  std::string* _internal_mutable_attachmentdirectpath();
  public:

  // optional bytes attachmentJpegThumbnail = 10;
  bool has_attachmentjpegthumbnail() const;
  private:
  bool _internal_has_attachmentjpegthumbnail() const;
  public:
  void clear_attachmentjpegthumbnail();
  const std::string& attachmentjpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_attachmentjpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_attachmentjpegthumbnail();
  void set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail);
  private:
  const std::string& _internal_attachmentjpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_attachmentjpegthumbnail(const std::string& value);
  std::string* _internal_mutable_attachmentjpegthumbnail();
  public:

  // optional int64 attachmentMediaKeyTimestamp = 6;
  bool has_attachmentmediakeytimestamp() const;
  private:
  bool _internal_has_attachmentmediakeytimestamp() const;
  public:
  void clear_attachmentmediakeytimestamp();
  int64_t attachmentmediakeytimestamp() const;
  void set_attachmentmediakeytimestamp(int64_t value);
  private:
  int64_t _internal_attachmentmediakeytimestamp() const;
  void _internal_set_attachmentmediakeytimestamp(int64_t value);
  public:

  // optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
  bool has_attachmenttype() const;
  private:
  bool _internal_has_attachmenttype() const;
  public:
  void clear_attachmenttype();
  ::proto::Message_InvoiceMessage_AttachmentType attachmenttype() const;
  void set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value);
  private:
  ::proto::Message_InvoiceMessage_AttachmentType _internal_attachmenttype() const;
  void _internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.InvoiceMessage)
 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 note_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentmediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfilesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentfileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentdirectpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr attachmentjpegthumbnail_;
    int64_t attachmentmediakeytimestamp_;
    int attachmenttype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_KeepInChatMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.KeepInChatMessage) */ {
 public:
  inline Message_KeepInChatMessage() : Message_KeepInChatMessage(nullptr) {}
  ~Message_KeepInChatMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_KeepInChatMessage(const Message_KeepInChatMessage& from);
  Message_KeepInChatMessage(Message_KeepInChatMessage&& from) noexcept
    : Message_KeepInChatMessage() {
    *this = ::std::move(from);
  }

  inline Message_KeepInChatMessage& operator=(const Message_KeepInChatMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_KeepInChatMessage& operator=(Message_KeepInChatMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_KeepInChatMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_KeepInChatMessage* internal_default_instance() {
    return reinterpret_cast<const Message_KeepInChatMessage*>(
               &_Message_KeepInChatMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    98;

  friend void swap(Message_KeepInChatMessage& a, Message_KeepInChatMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_KeepInChatMessage* 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(Message_KeepInChatMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_KeepInChatMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_KeepInChatMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_KeepInChatMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_KeepInChatMessage& from) {
    Message_KeepInChatMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_KeepInChatMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.KeepInChatMessage";
  }
  protected:
  explicit Message_KeepInChatMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kTimestampMsFieldNumber = 3,
    kKeepTypeFieldNumber = 2,
  };
  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional int64 timestampMs = 3;
  bool has_timestampms() const;
  private:
  bool _internal_has_timestampms() const;
  public:
  void clear_timestampms();
  int64_t timestampms() const;
  void set_timestampms(int64_t value);
  private:
  int64_t _internal_timestampms() const;
  void _internal_set_timestampms(int64_t value);
  public:

  // optional .proto.KeepType keepType = 2;
  bool has_keeptype() const;
  private:
  bool _internal_has_keeptype() const;
  public:
  void clear_keeptype();
  ::proto::KeepType keeptype() const;
  void set_keeptype(::proto::KeepType value);
  private:
  ::proto::KeepType _internal_keeptype() const;
  void _internal_set_keeptype(::proto::KeepType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.KeepInChatMessage)
 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_;
    ::proto::MessageKey* key_;
    int64_t timestampms_;
    int keeptype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_ProductListHeaderImage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListHeaderImage) */ {
 public:
  inline Message_ListMessage_ProductListHeaderImage() : Message_ListMessage_ProductListHeaderImage(nullptr) {}
  ~Message_ListMessage_ProductListHeaderImage() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_ProductListHeaderImage(const Message_ListMessage_ProductListHeaderImage& from);
  Message_ListMessage_ProductListHeaderImage(Message_ListMessage_ProductListHeaderImage&& from) noexcept
    : Message_ListMessage_ProductListHeaderImage() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_ProductListHeaderImage& operator=(const Message_ListMessage_ProductListHeaderImage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_ProductListHeaderImage& operator=(Message_ListMessage_ProductListHeaderImage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_ProductListHeaderImage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_ProductListHeaderImage* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_ProductListHeaderImage*>(
               &_Message_ListMessage_ProductListHeaderImage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    99;

  friend void swap(Message_ListMessage_ProductListHeaderImage& a, Message_ListMessage_ProductListHeaderImage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_ProductListHeaderImage* 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(Message_ListMessage_ProductListHeaderImage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_ProductListHeaderImage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_ProductListHeaderImage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_ProductListHeaderImage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_ProductListHeaderImage& from) {
    Message_ListMessage_ProductListHeaderImage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_ProductListHeaderImage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.ProductListHeaderImage";
  }
  protected:
  explicit Message_ListMessage_ProductListHeaderImage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductIdFieldNumber = 1,
    kJpegThumbnailFieldNumber = 2,
  };
  // optional string productId = 1;
  bool has_productid() const;
  private:
  bool _internal_has_productid() const;
  public:
  void clear_productid();
  const std::string& productid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_productid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_productid();
  PROTOBUF_NODISCARD std::string* release_productid();
  void set_allocated_productid(std::string* productid);
  private:
  const std::string& _internal_productid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
  std::string* _internal_mutable_productid();
  public:

  // optional bytes jpegThumbnail = 2;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListHeaderImage)
 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 productid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_ProductListInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductListInfo) */ {
 public:
  inline Message_ListMessage_ProductListInfo() : Message_ListMessage_ProductListInfo(nullptr) {}
  ~Message_ListMessage_ProductListInfo() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_ProductListInfo(const Message_ListMessage_ProductListInfo& from);
  Message_ListMessage_ProductListInfo(Message_ListMessage_ProductListInfo&& from) noexcept
    : Message_ListMessage_ProductListInfo() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_ProductListInfo& operator=(const Message_ListMessage_ProductListInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_ProductListInfo& operator=(Message_ListMessage_ProductListInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_ProductListInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_ProductListInfo* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_ProductListInfo*>(
               &_Message_ListMessage_ProductListInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    100;

  friend void swap(Message_ListMessage_ProductListInfo& a, Message_ListMessage_ProductListInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_ProductListInfo* 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(Message_ListMessage_ProductListInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_ProductListInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_ProductListInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_ProductListInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_ProductListInfo& from) {
    Message_ListMessage_ProductListInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_ProductListInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.ProductListInfo";
  }
  protected:
  explicit Message_ListMessage_ProductListInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductSectionsFieldNumber = 1,
    kBusinessOwnerJidFieldNumber = 3,
    kHeaderImageFieldNumber = 2,
  };
  // repeated .proto.Message.ListMessage.ProductSection productSections = 1;
  int productsections_size() const;
  private:
  int _internal_productsections_size() const;
  public:
  void clear_productsections();
  ::proto::Message_ListMessage_ProductSection* mutable_productsections(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >*
      mutable_productsections();
  private:
  const ::proto::Message_ListMessage_ProductSection& _internal_productsections(int index) const;
  ::proto::Message_ListMessage_ProductSection* _internal_add_productsections();
  public:
  const ::proto::Message_ListMessage_ProductSection& productsections(int index) const;
  ::proto::Message_ListMessage_ProductSection* add_productsections();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >&
      productsections() const;

  // optional string businessOwnerJid = 3;
  bool has_businessownerjid() const;
  private:
  bool _internal_has_businessownerjid() const;
  public:
  void clear_businessownerjid();
  const std::string& businessownerjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_businessownerjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_businessownerjid();
  PROTOBUF_NODISCARD std::string* release_businessownerjid();
  void set_allocated_businessownerjid(std::string* businessownerjid);
  private:
  const std::string& _internal_businessownerjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value);
  std::string* _internal_mutable_businessownerjid();
  public:

  // optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
  bool has_headerimage() const;
  private:
  bool _internal_has_headerimage() const;
  public:
  void clear_headerimage();
  const ::proto::Message_ListMessage_ProductListHeaderImage& headerimage() const;
  PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListHeaderImage* release_headerimage();
  ::proto::Message_ListMessage_ProductListHeaderImage* mutable_headerimage();
  void set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage);
  private:
  const ::proto::Message_ListMessage_ProductListHeaderImage& _internal_headerimage() const;
  ::proto::Message_ListMessage_ProductListHeaderImage* _internal_mutable_headerimage();
  public:
  void unsafe_arena_set_allocated_headerimage(
      ::proto::Message_ListMessage_ProductListHeaderImage* headerimage);
  ::proto::Message_ListMessage_ProductListHeaderImage* unsafe_arena_release_headerimage();

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductListInfo)
 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< ::proto::Message_ListMessage_ProductSection > productsections_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr businessownerjid_;
    ::proto::Message_ListMessage_ProductListHeaderImage* headerimage_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_ProductSection final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.ProductSection) */ {
 public:
  inline Message_ListMessage_ProductSection() : Message_ListMessage_ProductSection(nullptr) {}
  ~Message_ListMessage_ProductSection() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_ProductSection(const Message_ListMessage_ProductSection& from);
  Message_ListMessage_ProductSection(Message_ListMessage_ProductSection&& from) noexcept
    : Message_ListMessage_ProductSection() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_ProductSection& operator=(const Message_ListMessage_ProductSection& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_ProductSection& operator=(Message_ListMessage_ProductSection&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_ProductSection& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_ProductSection* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_ProductSection*>(
               &_Message_ListMessage_ProductSection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    101;

  friend void swap(Message_ListMessage_ProductSection& a, Message_ListMessage_ProductSection& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_ProductSection* 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(Message_ListMessage_ProductSection* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_ProductSection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_ProductSection>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_ProductSection& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_ProductSection& from) {
    Message_ListMessage_ProductSection::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_ProductSection* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.ProductSection";
  }
  protected:
  explicit Message_ListMessage_ProductSection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductsFieldNumber = 2,
    kTitleFieldNumber = 1,
  };
  // repeated .proto.Message.ListMessage.Product products = 2;
  int products_size() const;
  private:
  int _internal_products_size() const;
  public:
  void clear_products();
  ::proto::Message_ListMessage_Product* mutable_products(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >*
      mutable_products();
  private:
  const ::proto::Message_ListMessage_Product& _internal_products(int index) const;
  ::proto::Message_ListMessage_Product* _internal_add_products();
  public:
  const ::proto::Message_ListMessage_Product& products(int index) const;
  ::proto::Message_ListMessage_Product* add_products();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >&
      products() const;

  // optional string title = 1;
  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:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.ProductSection)
 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< ::proto::Message_ListMessage_Product > products_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_Product final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Product) */ {
 public:
  inline Message_ListMessage_Product() : Message_ListMessage_Product(nullptr) {}
  ~Message_ListMessage_Product() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_Product(const Message_ListMessage_Product& from);
  Message_ListMessage_Product(Message_ListMessage_Product&& from) noexcept
    : Message_ListMessage_Product() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_Product& operator=(const Message_ListMessage_Product& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_Product& operator=(Message_ListMessage_Product&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_Product& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_Product* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_Product*>(
               &_Message_ListMessage_Product_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    102;

  friend void swap(Message_ListMessage_Product& a, Message_ListMessage_Product& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_Product* 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(Message_ListMessage_Product* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_Product* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_Product>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_Product& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_Product& from) {
    Message_ListMessage_Product::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_Product* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.Product";
  }
  protected:
  explicit Message_ListMessage_Product(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductIdFieldNumber = 1,
  };
  // optional string productId = 1;
  bool has_productid() const;
  private:
  bool _internal_has_productid() const;
  public:
  void clear_productid();
  const std::string& productid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_productid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_productid();
  PROTOBUF_NODISCARD std::string* release_productid();
  void set_allocated_productid(std::string* productid);
  private:
  const std::string& _internal_productid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
  std::string* _internal_mutable_productid();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Product)
 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 productid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_Row final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Row) */ {
 public:
  inline Message_ListMessage_Row() : Message_ListMessage_Row(nullptr) {}
  ~Message_ListMessage_Row() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_Row(const Message_ListMessage_Row& from);
  Message_ListMessage_Row(Message_ListMessage_Row&& from) noexcept
    : Message_ListMessage_Row() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_Row& operator=(const Message_ListMessage_Row& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_Row& operator=(Message_ListMessage_Row&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_Row& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_Row* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_Row*>(
               &_Message_ListMessage_Row_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    103;

  friend void swap(Message_ListMessage_Row& a, Message_ListMessage_Row& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_Row* 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(Message_ListMessage_Row* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_Row* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_Row>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_Row& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_Row& from) {
    Message_ListMessage_Row::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_Row* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.Row";
  }
  protected:
  explicit Message_ListMessage_Row(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTitleFieldNumber = 1,
    kDescriptionFieldNumber = 2,
    kRowIdFieldNumber = 3,
  };
  // optional string title = 1;
  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 string description = 2;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional string rowId = 3;
  bool has_rowid() const;
  private:
  bool _internal_has_rowid() const;
  public:
  void clear_rowid();
  const std::string& rowid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rowid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rowid();
  PROTOBUF_NODISCARD std::string* release_rowid();
  void set_allocated_rowid(std::string* rowid);
  private:
  const std::string& _internal_rowid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rowid(const std::string& value);
  std::string* _internal_mutable_rowid();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Row)
 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 title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rowid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage_Section final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage.Section) */ {
 public:
  inline Message_ListMessage_Section() : Message_ListMessage_Section(nullptr) {}
  ~Message_ListMessage_Section() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage_Section(const Message_ListMessage_Section& from);
  Message_ListMessage_Section(Message_ListMessage_Section&& from) noexcept
    : Message_ListMessage_Section() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage_Section& operator=(const Message_ListMessage_Section& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage_Section& operator=(Message_ListMessage_Section&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage_Section& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage_Section* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage_Section*>(
               &_Message_ListMessage_Section_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    104;

  friend void swap(Message_ListMessage_Section& a, Message_ListMessage_Section& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage_Section* 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(Message_ListMessage_Section* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage_Section* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage_Section>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage_Section& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage_Section& from) {
    Message_ListMessage_Section::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage_Section* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage.Section";
  }
  protected:
  explicit Message_ListMessage_Section(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRowsFieldNumber = 2,
    kTitleFieldNumber = 1,
  };
  // repeated .proto.Message.ListMessage.Row rows = 2;
  int rows_size() const;
  private:
  int _internal_rows_size() const;
  public:
  void clear_rows();
  ::proto::Message_ListMessage_Row* mutable_rows(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >*
      mutable_rows();
  private:
  const ::proto::Message_ListMessage_Row& _internal_rows(int index) const;
  ::proto::Message_ListMessage_Row* _internal_add_rows();
  public:
  const ::proto::Message_ListMessage_Row& rows(int index) const;
  ::proto::Message_ListMessage_Row* add_rows();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >&
      rows() const;

  // optional string title = 1;
  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:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage.Section)
 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< ::proto::Message_ListMessage_Row > rows_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListMessage) */ {
 public:
  inline Message_ListMessage() : Message_ListMessage(nullptr) {}
  ~Message_ListMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ListMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListMessage(const Message_ListMessage& from);
  Message_ListMessage(Message_ListMessage&& from) noexcept
    : Message_ListMessage() {
    *this = ::std::move(from);
  }

  inline Message_ListMessage& operator=(const Message_ListMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListMessage& operator=(Message_ListMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ListMessage*>(
               &_Message_ListMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    105;

  friend void swap(Message_ListMessage& a, Message_ListMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListMessage* 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(Message_ListMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListMessage& from) {
    Message_ListMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListMessage";
  }
  protected:
  explicit Message_ListMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ListMessage_ProductListHeaderImage ProductListHeaderImage;
  typedef Message_ListMessage_ProductListInfo ProductListInfo;
  typedef Message_ListMessage_ProductSection ProductSection;
  typedef Message_ListMessage_Product Product;
  typedef Message_ListMessage_Row Row;
  typedef Message_ListMessage_Section Section;

  typedef Message_ListMessage_ListType ListType;
  static constexpr ListType UNKNOWN =
    Message_ListMessage_ListType_UNKNOWN;
  static constexpr ListType SINGLE_SELECT =
    Message_ListMessage_ListType_SINGLE_SELECT;
  static constexpr ListType PRODUCT_LIST =
    Message_ListMessage_ListType_PRODUCT_LIST;
  static inline bool ListType_IsValid(int value) {
    return Message_ListMessage_ListType_IsValid(value);
  }
  static constexpr ListType ListType_MIN =
    Message_ListMessage_ListType_ListType_MIN;
  static constexpr ListType ListType_MAX =
    Message_ListMessage_ListType_ListType_MAX;
  static constexpr int ListType_ARRAYSIZE =
    Message_ListMessage_ListType_ListType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ListType_descriptor() {
    return Message_ListMessage_ListType_descriptor();
  }
  template<typename T>
  static inline const std::string& ListType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ListType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ListType_Name.");
    return Message_ListMessage_ListType_Name(enum_t_value);
  }
  static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ListType* value) {
    return Message_ListMessage_ListType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kSectionsFieldNumber = 5,
    kTitleFieldNumber = 1,
    kDescriptionFieldNumber = 2,
    kButtonTextFieldNumber = 3,
    kFooterTextFieldNumber = 7,
    kProductListInfoFieldNumber = 6,
    kContextInfoFieldNumber = 8,
    kListTypeFieldNumber = 4,
  };
  // repeated .proto.Message.ListMessage.Section sections = 5;
  int sections_size() const;
  private:
  int _internal_sections_size() const;
  public:
  void clear_sections();
  ::proto::Message_ListMessage_Section* mutable_sections(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >*
      mutable_sections();
  private:
  const ::proto::Message_ListMessage_Section& _internal_sections(int index) const;
  ::proto::Message_ListMessage_Section* _internal_add_sections();
  public:
  const ::proto::Message_ListMessage_Section& sections(int index) const;
  ::proto::Message_ListMessage_Section* add_sections();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >&
      sections() const;

  // optional string title = 1;
  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 string description = 2;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional string buttonText = 3;
  bool has_buttontext() const;
  private:
  bool _internal_has_buttontext() const;
  public:
  void clear_buttontext();
  const std::string& buttontext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_buttontext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_buttontext();
  PROTOBUF_NODISCARD std::string* release_buttontext();
  void set_allocated_buttontext(std::string* buttontext);
  private:
  const std::string& _internal_buttontext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_buttontext(const std::string& value);
  std::string* _internal_mutable_buttontext();
  public:

  // optional string footerText = 7;
  bool has_footertext() const;
  private:
  bool _internal_has_footertext() const;
  public:
  void clear_footertext();
  const std::string& footertext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_footertext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_footertext();
  PROTOBUF_NODISCARD std::string* release_footertext();
  void set_allocated_footertext(std::string* footertext);
  private:
  const std::string& _internal_footertext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footertext(const std::string& value);
  std::string* _internal_mutable_footertext();
  public:

  // optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
  bool has_productlistinfo() const;
  private:
  bool _internal_has_productlistinfo() const;
  public:
  void clear_productlistinfo();
  const ::proto::Message_ListMessage_ProductListInfo& productlistinfo() const;
  PROTOBUF_NODISCARD ::proto::Message_ListMessage_ProductListInfo* release_productlistinfo();
  ::proto::Message_ListMessage_ProductListInfo* mutable_productlistinfo();
  void set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo);
  private:
  const ::proto::Message_ListMessage_ProductListInfo& _internal_productlistinfo() const;
  ::proto::Message_ListMessage_ProductListInfo* _internal_mutable_productlistinfo();
  public:
  void unsafe_arena_set_allocated_productlistinfo(
      ::proto::Message_ListMessage_ProductListInfo* productlistinfo);
  ::proto::Message_ListMessage_ProductListInfo* unsafe_arena_release_productlistinfo();

  // optional .proto.ContextInfo contextInfo = 8;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional .proto.Message.ListMessage.ListType listType = 4;
  bool has_listtype() const;
  private:
  bool _internal_has_listtype() const;
  public:
  void clear_listtype();
  ::proto::Message_ListMessage_ListType listtype() const;
  void set_listtype(::proto::Message_ListMessage_ListType value);
  private:
  ::proto::Message_ListMessage_ListType _internal_listtype() const;
  void _internal_set_listtype(::proto::Message_ListMessage_ListType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListMessage)
 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< ::proto::Message_ListMessage_Section > sections_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buttontext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footertext_;
    ::proto::Message_ListMessage_ProductListInfo* productlistinfo_;
    ::proto::ContextInfo* contextinfo_;
    int listtype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListResponseMessage_SingleSelectReply final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage.SingleSelectReply) */ {
 public:
  inline Message_ListResponseMessage_SingleSelectReply() : Message_ListResponseMessage_SingleSelectReply(nullptr) {}
  ~Message_ListResponseMessage_SingleSelectReply() override;
  explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListResponseMessage_SingleSelectReply(const Message_ListResponseMessage_SingleSelectReply& from);
  Message_ListResponseMessage_SingleSelectReply(Message_ListResponseMessage_SingleSelectReply&& from) noexcept
    : Message_ListResponseMessage_SingleSelectReply() {
    *this = ::std::move(from);
  }

  inline Message_ListResponseMessage_SingleSelectReply& operator=(const Message_ListResponseMessage_SingleSelectReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListResponseMessage_SingleSelectReply& operator=(Message_ListResponseMessage_SingleSelectReply&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListResponseMessage_SingleSelectReply& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListResponseMessage_SingleSelectReply* internal_default_instance() {
    return reinterpret_cast<const Message_ListResponseMessage_SingleSelectReply*>(
               &_Message_ListResponseMessage_SingleSelectReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    106;

  friend void swap(Message_ListResponseMessage_SingleSelectReply& a, Message_ListResponseMessage_SingleSelectReply& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListResponseMessage_SingleSelectReply* 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(Message_ListResponseMessage_SingleSelectReply* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListResponseMessage_SingleSelectReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListResponseMessage_SingleSelectReply>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListResponseMessage_SingleSelectReply& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListResponseMessage_SingleSelectReply& from) {
    Message_ListResponseMessage_SingleSelectReply::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListResponseMessage_SingleSelectReply* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListResponseMessage.SingleSelectReply";
  }
  protected:
  explicit Message_ListResponseMessage_SingleSelectReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSelectedRowIdFieldNumber = 1,
  };
  // optional string selectedRowId = 1;
  bool has_selectedrowid() const;
  private:
  bool _internal_has_selectedrowid() const;
  public:
  void clear_selectedrowid();
  const std::string& selectedrowid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_selectedrowid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_selectedrowid();
  PROTOBUF_NODISCARD std::string* release_selectedrowid();
  void set_allocated_selectedrowid(std::string* selectedrowid);
  private:
  const std::string& _internal_selectedrowid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedrowid(const std::string& value);
  std::string* _internal_mutable_selectedrowid();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage.SingleSelectReply)
 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 selectedrowid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ListResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ListResponseMessage) */ {
 public:
  inline Message_ListResponseMessage() : Message_ListResponseMessage(nullptr) {}
  ~Message_ListResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ListResponseMessage(const Message_ListResponseMessage& from);
  Message_ListResponseMessage(Message_ListResponseMessage&& from) noexcept
    : Message_ListResponseMessage() {
    *this = ::std::move(from);
  }

  inline Message_ListResponseMessage& operator=(const Message_ListResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ListResponseMessage& operator=(Message_ListResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ListResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ListResponseMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ListResponseMessage*>(
               &_Message_ListResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    107;

  friend void swap(Message_ListResponseMessage& a, Message_ListResponseMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ListResponseMessage* 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(Message_ListResponseMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ListResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ListResponseMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ListResponseMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ListResponseMessage& from) {
    Message_ListResponseMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ListResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ListResponseMessage";
  }
  protected:
  explicit Message_ListResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ListResponseMessage_SingleSelectReply SingleSelectReply;

  typedef Message_ListResponseMessage_ListType ListType;
  static constexpr ListType UNKNOWN =
    Message_ListResponseMessage_ListType_UNKNOWN;
  static constexpr ListType SINGLE_SELECT =
    Message_ListResponseMessage_ListType_SINGLE_SELECT;
  static inline bool ListType_IsValid(int value) {
    return Message_ListResponseMessage_ListType_IsValid(value);
  }
  static constexpr ListType ListType_MIN =
    Message_ListResponseMessage_ListType_ListType_MIN;
  static constexpr ListType ListType_MAX =
    Message_ListResponseMessage_ListType_ListType_MAX;
  static constexpr int ListType_ARRAYSIZE =
    Message_ListResponseMessage_ListType_ListType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ListType_descriptor() {
    return Message_ListResponseMessage_ListType_descriptor();
  }
  template<typename T>
  static inline const std::string& ListType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ListType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ListType_Name.");
    return Message_ListResponseMessage_ListType_Name(enum_t_value);
  }
  static inline bool ListType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ListType* value) {
    return Message_ListResponseMessage_ListType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTitleFieldNumber = 1,
    kDescriptionFieldNumber = 5,
    kSingleSelectReplyFieldNumber = 3,
    kContextInfoFieldNumber = 4,
    kListTypeFieldNumber = 2,
  };
  // optional string title = 1;
  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 string description = 5;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
  bool has_singleselectreply() const;
  private:
  bool _internal_has_singleselectreply() const;
  public:
  void clear_singleselectreply();
  const ::proto::Message_ListResponseMessage_SingleSelectReply& singleselectreply() const;
  PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage_SingleSelectReply* release_singleselectreply();
  ::proto::Message_ListResponseMessage_SingleSelectReply* mutable_singleselectreply();
  void set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply);
  private:
  const ::proto::Message_ListResponseMessage_SingleSelectReply& _internal_singleselectreply() const;
  ::proto::Message_ListResponseMessage_SingleSelectReply* _internal_mutable_singleselectreply();
  public:
  void unsafe_arena_set_allocated_singleselectreply(
      ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply);
  ::proto::Message_ListResponseMessage_SingleSelectReply* unsafe_arena_release_singleselectreply();

  // optional .proto.ContextInfo contextInfo = 4;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional .proto.Message.ListResponseMessage.ListType listType = 2;
  bool has_listtype() const;
  private:
  bool _internal_has_listtype() const;
  public:
  void clear_listtype();
  ::proto::Message_ListResponseMessage_ListType listtype() const;
  void set_listtype(::proto::Message_ListResponseMessage_ListType value);
  private:
  ::proto::Message_ListResponseMessage_ListType _internal_listtype() const;
  void _internal_set_listtype(::proto::Message_ListResponseMessage_ListType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ListResponseMessage)
 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 title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply_;
    ::proto::ContextInfo* contextinfo_;
    int listtype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_LiveLocationMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LiveLocationMessage) */ {
 public:
  inline Message_LiveLocationMessage() : Message_LiveLocationMessage(nullptr) {}
  ~Message_LiveLocationMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_LiveLocationMessage(const Message_LiveLocationMessage& from);
  Message_LiveLocationMessage(Message_LiveLocationMessage&& from) noexcept
    : Message_LiveLocationMessage() {
    *this = ::std::move(from);
  }

  inline Message_LiveLocationMessage& operator=(const Message_LiveLocationMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_LiveLocationMessage& operator=(Message_LiveLocationMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_LiveLocationMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_LiveLocationMessage* internal_default_instance() {
    return reinterpret_cast<const Message_LiveLocationMessage*>(
               &_Message_LiveLocationMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    108;

  friend void swap(Message_LiveLocationMessage& a, Message_LiveLocationMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_LiveLocationMessage* 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(Message_LiveLocationMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_LiveLocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_LiveLocationMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_LiveLocationMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_LiveLocationMessage& from) {
    Message_LiveLocationMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_LiveLocationMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.LiveLocationMessage";
  }
  protected:
  explicit Message_LiveLocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCaptionFieldNumber = 6,
    kJpegThumbnailFieldNumber = 16,
    kContextInfoFieldNumber = 17,
    kDegreesLatitudeFieldNumber = 1,
    kDegreesLongitudeFieldNumber = 2,
    kAccuracyInMetersFieldNumber = 3,
    kSpeedInMpsFieldNumber = 4,
    kDegreesClockwiseFromMagneticNorthFieldNumber = 5,
    kTimeOffsetFieldNumber = 8,
    kSequenceNumberFieldNumber = 7,
  };
  // optional string caption = 6;
  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 bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional double degreesLatitude = 1;
  bool has_degreeslatitude() const;
  private:
  bool _internal_has_degreeslatitude() const;
  public:
  void clear_degreeslatitude();
  double degreeslatitude() const;
  void set_degreeslatitude(double value);
  private:
  double _internal_degreeslatitude() const;
  void _internal_set_degreeslatitude(double value);
  public:

  // optional double degreesLongitude = 2;
  bool has_degreeslongitude() const;
  private:
  bool _internal_has_degreeslongitude() const;
  public:
  void clear_degreeslongitude();
  double degreeslongitude() const;
  void set_degreeslongitude(double value);
  private:
  double _internal_degreeslongitude() const;
  void _internal_set_degreeslongitude(double value);
  public:

  // optional uint32 accuracyInMeters = 3;
  bool has_accuracyinmeters() const;
  private:
  bool _internal_has_accuracyinmeters() const;
  public:
  void clear_accuracyinmeters();
  uint32_t accuracyinmeters() const;
  void set_accuracyinmeters(uint32_t value);
  private:
  uint32_t _internal_accuracyinmeters() const;
  void _internal_set_accuracyinmeters(uint32_t value);
  public:

  // optional float speedInMps = 4;
  bool has_speedinmps() const;
  private:
  bool _internal_has_speedinmps() const;
  public:
  void clear_speedinmps();
  float speedinmps() const;
  void set_speedinmps(float value);
  private:
  float _internal_speedinmps() const;
  void _internal_set_speedinmps(float value);
  public:

  // optional uint32 degreesClockwiseFromMagneticNorth = 5;
  bool has_degreesclockwisefrommagneticnorth() const;
  private:
  bool _internal_has_degreesclockwisefrommagneticnorth() const;
  public:
  void clear_degreesclockwisefrommagneticnorth();
  uint32_t degreesclockwisefrommagneticnorth() const;
  void set_degreesclockwisefrommagneticnorth(uint32_t value);
  private:
  uint32_t _internal_degreesclockwisefrommagneticnorth() const;
  void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value);
  public:

  // optional uint32 timeOffset = 8;
  bool has_timeoffset() const;
  private:
  bool _internal_has_timeoffset() const;
  public:
  void clear_timeoffset();
  uint32_t timeoffset() const;
  void set_timeoffset(uint32_t value);
  private:
  uint32_t _internal_timeoffset() const;
  void _internal_set_timeoffset(uint32_t value);
  public:

  // optional int64 sequenceNumber = 7;
  bool has_sequencenumber() const;
  private:
  bool _internal_has_sequencenumber() const;
  public:
  void clear_sequencenumber();
  int64_t sequencenumber() const;
  void set_sequencenumber(int64_t value);
  private:
  int64_t _internal_sequencenumber() const;
  void _internal_set_sequencenumber(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.LiveLocationMessage)
 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 caption_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::proto::ContextInfo* contextinfo_;
    double degreeslatitude_;
    double degreeslongitude_;
    uint32_t accuracyinmeters_;
    float speedinmps_;
    uint32_t degreesclockwisefrommagneticnorth_;
    uint32_t timeoffset_;
    int64_t sequencenumber_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_LocationMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.LocationMessage) */ {
 public:
  inline Message_LocationMessage() : Message_LocationMessage(nullptr) {}
  ~Message_LocationMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_LocationMessage(const Message_LocationMessage& from);
  Message_LocationMessage(Message_LocationMessage&& from) noexcept
    : Message_LocationMessage() {
    *this = ::std::move(from);
  }

  inline Message_LocationMessage& operator=(const Message_LocationMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_LocationMessage& operator=(Message_LocationMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_LocationMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_LocationMessage* internal_default_instance() {
    return reinterpret_cast<const Message_LocationMessage*>(
               &_Message_LocationMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    109;

  friend void swap(Message_LocationMessage& a, Message_LocationMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_LocationMessage* 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(Message_LocationMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_LocationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_LocationMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_LocationMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_LocationMessage& from) {
    Message_LocationMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_LocationMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.LocationMessage";
  }
  protected:
  explicit Message_LocationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 3,
    kAddressFieldNumber = 4,
    kUrlFieldNumber = 5,
    kCommentFieldNumber = 11,
    kJpegThumbnailFieldNumber = 16,
    kContextInfoFieldNumber = 17,
    kDegreesLatitudeFieldNumber = 1,
    kDegreesLongitudeFieldNumber = 2,
    kIsLiveFieldNumber = 6,
    kAccuracyInMetersFieldNumber = 7,
    kSpeedInMpsFieldNumber = 8,
    kDegreesClockwiseFromMagneticNorthFieldNumber = 9,
  };
  // optional 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:

  // optional string address = 4;
  bool has_address() const;
  private:
  bool _internal_has_address() const;
  public:
  void clear_address();
  const std::string& address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_address();
  PROTOBUF_NODISCARD std::string* release_address();
  void set_allocated_address(std::string* address);
  private:
  const std::string& _internal_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_address(const std::string& value);
  std::string* _internal_mutable_address();
  public:

  // optional string url = 5;
  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 comment = 11;
  bool has_comment() const;
  private:
  bool _internal_has_comment() const;
  public:
  void clear_comment();
  const std::string& comment() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_comment(ArgT0&& arg0, ArgT... args);
  std::string* mutable_comment();
  PROTOBUF_NODISCARD std::string* release_comment();
  void set_allocated_comment(std::string* comment);
  private:
  const std::string& _internal_comment() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_comment(const std::string& value);
  std::string* _internal_mutable_comment();
  public:

  // optional bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional double degreesLatitude = 1;
  bool has_degreeslatitude() const;
  private:
  bool _internal_has_degreeslatitude() const;
  public:
  void clear_degreeslatitude();
  double degreeslatitude() const;
  void set_degreeslatitude(double value);
  private:
  double _internal_degreeslatitude() const;
  void _internal_set_degreeslatitude(double value);
  public:

  // optional double degreesLongitude = 2;
  bool has_degreeslongitude() const;
  private:
  bool _internal_has_degreeslongitude() const;
  public:
  void clear_degreeslongitude();
  double degreeslongitude() const;
  void set_degreeslongitude(double value);
  private:
  double _internal_degreeslongitude() const;
  void _internal_set_degreeslongitude(double value);
  public:

  // optional bool isLive = 6;
  bool has_islive() const;
  private:
  bool _internal_has_islive() const;
  public:
  void clear_islive();
  bool islive() const;
  void set_islive(bool value);
  private:
  bool _internal_islive() const;
  void _internal_set_islive(bool value);
  public:

  // optional uint32 accuracyInMeters = 7;
  bool has_accuracyinmeters() const;
  private:
  bool _internal_has_accuracyinmeters() const;
  public:
  void clear_accuracyinmeters();
  uint32_t accuracyinmeters() const;
  void set_accuracyinmeters(uint32_t value);
  private:
  uint32_t _internal_accuracyinmeters() const;
  void _internal_set_accuracyinmeters(uint32_t value);
  public:

  // optional float speedInMps = 8;
  bool has_speedinmps() const;
  private:
  bool _internal_has_speedinmps() const;
  public:
  void clear_speedinmps();
  float speedinmps() const;
  void set_speedinmps(float value);
  private:
  float _internal_speedinmps() const;
  void _internal_set_speedinmps(float value);
  public:

  // optional uint32 degreesClockwiseFromMagneticNorth = 9;
  bool has_degreesclockwisefrommagneticnorth() const;
  private:
  bool _internal_has_degreesclockwisefrommagneticnorth() const;
  public:
  void clear_degreesclockwisefrommagneticnorth();
  uint32_t degreesclockwisefrommagneticnorth() const;
  void set_degreesclockwisefrommagneticnorth(uint32_t value);
  private:
  uint32_t _internal_degreesclockwisefrommagneticnorth() const;
  void _internal_set_degreesclockwisefrommagneticnorth(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.LocationMessage)
 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 name_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr address_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comment_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::proto::ContextInfo* contextinfo_;
    double degreeslatitude_;
    double degreeslongitude_;
    bool islive_;
    uint32_t accuracyinmeters_;
    float speedinmps_;
    uint32_t degreesclockwisefrommagneticnorth_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_OrderMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.OrderMessage) */ {
 public:
  inline Message_OrderMessage() : Message_OrderMessage(nullptr) {}
  ~Message_OrderMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_OrderMessage(const Message_OrderMessage& from);
  Message_OrderMessage(Message_OrderMessage&& from) noexcept
    : Message_OrderMessage() {
    *this = ::std::move(from);
  }

  inline Message_OrderMessage& operator=(const Message_OrderMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_OrderMessage& operator=(Message_OrderMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_OrderMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_OrderMessage* internal_default_instance() {
    return reinterpret_cast<const Message_OrderMessage*>(
               &_Message_OrderMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    110;

  friend void swap(Message_OrderMessage& a, Message_OrderMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_OrderMessage* 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(Message_OrderMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_OrderMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_OrderMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_OrderMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_OrderMessage& from) {
    Message_OrderMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_OrderMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.OrderMessage";
  }
  protected:
  explicit Message_OrderMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_OrderMessage_OrderStatus OrderStatus;
  static constexpr OrderStatus INQUIRY =
    Message_OrderMessage_OrderStatus_INQUIRY;
  static inline bool OrderStatus_IsValid(int value) {
    return Message_OrderMessage_OrderStatus_IsValid(value);
  }
  static constexpr OrderStatus OrderStatus_MIN =
    Message_OrderMessage_OrderStatus_OrderStatus_MIN;
  static constexpr OrderStatus OrderStatus_MAX =
    Message_OrderMessage_OrderStatus_OrderStatus_MAX;
  static constexpr int OrderStatus_ARRAYSIZE =
    Message_OrderMessage_OrderStatus_OrderStatus_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OrderStatus_descriptor() {
    return Message_OrderMessage_OrderStatus_descriptor();
  }
  template<typename T>
  static inline const std::string& OrderStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OrderStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OrderStatus_Name.");
    return Message_OrderMessage_OrderStatus_Name(enum_t_value);
  }
  static inline bool OrderStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OrderStatus* value) {
    return Message_OrderMessage_OrderStatus_Parse(name, value);
  }

  typedef Message_OrderMessage_OrderSurface OrderSurface;
  static constexpr OrderSurface CATALOG =
    Message_OrderMessage_OrderSurface_CATALOG;
  static inline bool OrderSurface_IsValid(int value) {
    return Message_OrderMessage_OrderSurface_IsValid(value);
  }
  static constexpr OrderSurface OrderSurface_MIN =
    Message_OrderMessage_OrderSurface_OrderSurface_MIN;
  static constexpr OrderSurface OrderSurface_MAX =
    Message_OrderMessage_OrderSurface_OrderSurface_MAX;
  static constexpr int OrderSurface_ARRAYSIZE =
    Message_OrderMessage_OrderSurface_OrderSurface_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  OrderSurface_descriptor() {
    return Message_OrderMessage_OrderSurface_descriptor();
  }
  template<typename T>
  static inline const std::string& OrderSurface_Name(T enum_t_value) {
    static_assert(::std::is_same<T, OrderSurface>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function OrderSurface_Name.");
    return Message_OrderMessage_OrderSurface_Name(enum_t_value);
  }
  static inline bool OrderSurface_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      OrderSurface* value) {
    return Message_OrderMessage_OrderSurface_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kOrderIdFieldNumber = 1,
    kThumbnailFieldNumber = 2,
    kMessageFieldNumber = 6,
    kOrderTitleFieldNumber = 7,
    kSellerJidFieldNumber = 8,
    kTokenFieldNumber = 9,
    kTotalCurrencyCodeFieldNumber = 11,
    kContextInfoFieldNumber = 17,
    kTotalAmount1000FieldNumber = 10,
    kItemCountFieldNumber = 3,
    kStatusFieldNumber = 4,
    kSurfaceFieldNumber = 5,
  };
  // optional string orderId = 1;
  bool has_orderid() const;
  private:
  bool _internal_has_orderid() const;
  public:
  void clear_orderid();
  const std::string& orderid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_orderid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_orderid();
  PROTOBUF_NODISCARD std::string* release_orderid();
  void set_allocated_orderid(std::string* orderid);
  private:
  const std::string& _internal_orderid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_orderid(const std::string& value);
  std::string* _internal_mutable_orderid();
  public:

  // optional bytes thumbnail = 2;
  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 string message = 6;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // optional string orderTitle = 7;
  bool has_ordertitle() const;
  private:
  bool _internal_has_ordertitle() const;
  public:
  void clear_ordertitle();
  const std::string& ordertitle() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ordertitle(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ordertitle();
  PROTOBUF_NODISCARD std::string* release_ordertitle();
  void set_allocated_ordertitle(std::string* ordertitle);
  private:
  const std::string& _internal_ordertitle() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ordertitle(const std::string& value);
  std::string* _internal_mutable_ordertitle();
  public:

  // optional string sellerJid = 8;
  bool has_sellerjid() const;
  private:
  bool _internal_has_sellerjid() const;
  public:
  void clear_sellerjid();
  const std::string& sellerjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sellerjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sellerjid();
  PROTOBUF_NODISCARD std::string* release_sellerjid();
  void set_allocated_sellerjid(std::string* sellerjid);
  private:
  const std::string& _internal_sellerjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sellerjid(const std::string& value);
  std::string* _internal_mutable_sellerjid();
  public:

  // optional string token = 9;
  bool has_token() const;
  private:
  bool _internal_has_token() const;
  public:
  void clear_token();
  const std::string& token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_token();
  PROTOBUF_NODISCARD std::string* release_token();
  void set_allocated_token(std::string* token);
  private:
  const std::string& _internal_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
  std::string* _internal_mutable_token();
  public:

  // optional string totalCurrencyCode = 11;
  bool has_totalcurrencycode() const;
  private:
  bool _internal_has_totalcurrencycode() const;
  public:
  void clear_totalcurrencycode();
  const std::string& totalcurrencycode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_totalcurrencycode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_totalcurrencycode();
  PROTOBUF_NODISCARD std::string* release_totalcurrencycode();
  void set_allocated_totalcurrencycode(std::string* totalcurrencycode);
  private:
  const std::string& _internal_totalcurrencycode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_totalcurrencycode(const std::string& value);
  std::string* _internal_mutable_totalcurrencycode();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional int64 totalAmount1000 = 10;
  bool has_totalamount1000() const;
  private:
  bool _internal_has_totalamount1000() const;
  public:
  void clear_totalamount1000();
  int64_t totalamount1000() const;
  void set_totalamount1000(int64_t value);
  private:
  int64_t _internal_totalamount1000() const;
  void _internal_set_totalamount1000(int64_t value);
  public:

  // optional int32 itemCount = 3;
  bool has_itemcount() const;
  private:
  bool _internal_has_itemcount() const;
  public:
  void clear_itemcount();
  int32_t itemcount() const;
  void set_itemcount(int32_t value);
  private:
  int32_t _internal_itemcount() const;
  void _internal_set_itemcount(int32_t value);
  public:

  // optional .proto.Message.OrderMessage.OrderStatus status = 4;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::proto::Message_OrderMessage_OrderStatus status() const;
  void set_status(::proto::Message_OrderMessage_OrderStatus value);
  private:
  ::proto::Message_OrderMessage_OrderStatus _internal_status() const;
  void _internal_set_status(::proto::Message_OrderMessage_OrderStatus value);
  public:

  // optional .proto.Message.OrderMessage.OrderSurface surface = 5;
  bool has_surface() const;
  private:
  bool _internal_has_surface() const;
  public:
  void clear_surface();
  ::proto::Message_OrderMessage_OrderSurface surface() const;
  void set_surface(::proto::Message_OrderMessage_OrderSurface value);
  private:
  ::proto::Message_OrderMessage_OrderSurface _internal_surface() const;
  void _internal_set_surface(::proto::Message_OrderMessage_OrderSurface value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.OrderMessage)
 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 orderid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ordertitle_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sellerjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr totalcurrencycode_;
    ::proto::ContextInfo* contextinfo_;
    int64_t totalamount1000_;
    int32_t itemcount_;
    int status_;
    int surface_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PaymentInviteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PaymentInviteMessage) */ {
 public:
  inline Message_PaymentInviteMessage() : Message_PaymentInviteMessage(nullptr) {}
  ~Message_PaymentInviteMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PaymentInviteMessage(const Message_PaymentInviteMessage& from);
  Message_PaymentInviteMessage(Message_PaymentInviteMessage&& from) noexcept
    : Message_PaymentInviteMessage() {
    *this = ::std::move(from);
  }

  inline Message_PaymentInviteMessage& operator=(const Message_PaymentInviteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PaymentInviteMessage& operator=(Message_PaymentInviteMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PaymentInviteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PaymentInviteMessage* internal_default_instance() {
    return reinterpret_cast<const Message_PaymentInviteMessage*>(
               &_Message_PaymentInviteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    111;

  friend void swap(Message_PaymentInviteMessage& a, Message_PaymentInviteMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PaymentInviteMessage* 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(Message_PaymentInviteMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PaymentInviteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PaymentInviteMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PaymentInviteMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PaymentInviteMessage& from) {
    Message_PaymentInviteMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PaymentInviteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PaymentInviteMessage";
  }
  protected:
  explicit Message_PaymentInviteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_PaymentInviteMessage_ServiceType ServiceType;
  static constexpr ServiceType UNKNOWN =
    Message_PaymentInviteMessage_ServiceType_UNKNOWN;
  static constexpr ServiceType FBPAY =
    Message_PaymentInviteMessage_ServiceType_FBPAY;
  static constexpr ServiceType NOVI =
    Message_PaymentInviteMessage_ServiceType_NOVI;
  static constexpr ServiceType UPI =
    Message_PaymentInviteMessage_ServiceType_UPI;
  static inline bool ServiceType_IsValid(int value) {
    return Message_PaymentInviteMessage_ServiceType_IsValid(value);
  }
  static constexpr ServiceType ServiceType_MIN =
    Message_PaymentInviteMessage_ServiceType_ServiceType_MIN;
  static constexpr ServiceType ServiceType_MAX =
    Message_PaymentInviteMessage_ServiceType_ServiceType_MAX;
  static constexpr int ServiceType_ARRAYSIZE =
    Message_PaymentInviteMessage_ServiceType_ServiceType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ServiceType_descriptor() {
    return Message_PaymentInviteMessage_ServiceType_descriptor();
  }
  template<typename T>
  static inline const std::string& ServiceType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ServiceType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ServiceType_Name.");
    return Message_PaymentInviteMessage_ServiceType_Name(enum_t_value);
  }
  static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ServiceType* value) {
    return Message_PaymentInviteMessage_ServiceType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kExpiryTimestampFieldNumber = 2,
    kServiceTypeFieldNumber = 1,
  };
  // optional int64 expiryTimestamp = 2;
  bool has_expirytimestamp() const;
  private:
  bool _internal_has_expirytimestamp() const;
  public:
  void clear_expirytimestamp();
  int64_t expirytimestamp() const;
  void set_expirytimestamp(int64_t value);
  private:
  int64_t _internal_expirytimestamp() const;
  void _internal_set_expirytimestamp(int64_t value);
  public:

  // optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
  bool has_servicetype() const;
  private:
  bool _internal_has_servicetype() const;
  public:
  void clear_servicetype();
  ::proto::Message_PaymentInviteMessage_ServiceType servicetype() const;
  void set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value);
  private:
  ::proto::Message_PaymentInviteMessage_ServiceType _internal_servicetype() const;
  void _internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PaymentInviteMessage)
 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_;
    int64_t expirytimestamp_;
    int servicetype_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollCreationMessage_Option final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage.Option) */ {
 public:
  inline Message_PollCreationMessage_Option() : Message_PollCreationMessage_Option(nullptr) {}
  ~Message_PollCreationMessage_Option() override;
  explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollCreationMessage_Option(const Message_PollCreationMessage_Option& from);
  Message_PollCreationMessage_Option(Message_PollCreationMessage_Option&& from) noexcept
    : Message_PollCreationMessage_Option() {
    *this = ::std::move(from);
  }

  inline Message_PollCreationMessage_Option& operator=(const Message_PollCreationMessage_Option& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollCreationMessage_Option& operator=(Message_PollCreationMessage_Option&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollCreationMessage_Option& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollCreationMessage_Option* internal_default_instance() {
    return reinterpret_cast<const Message_PollCreationMessage_Option*>(
               &_Message_PollCreationMessage_Option_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    112;

  friend void swap(Message_PollCreationMessage_Option& a, Message_PollCreationMessage_Option& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollCreationMessage_Option* 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(Message_PollCreationMessage_Option* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollCreationMessage_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollCreationMessage_Option>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PollCreationMessage_Option& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PollCreationMessage_Option& from) {
    Message_PollCreationMessage_Option::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PollCreationMessage_Option* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollCreationMessage.Option";
  }
  protected:
  explicit Message_PollCreationMessage_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOptionNameFieldNumber = 1,
  };
  // optional string optionName = 1;
  bool has_optionname() const;
  private:
  bool _internal_has_optionname() const;
  public:
  void clear_optionname();
  const std::string& optionname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_optionname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_optionname();
  PROTOBUF_NODISCARD std::string* release_optionname();
  void set_allocated_optionname(std::string* optionname);
  private:
  const std::string& _internal_optionname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_optionname(const std::string& value);
  std::string* _internal_mutable_optionname();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage.Option)
 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 optionname_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollCreationMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollCreationMessage) */ {
 public:
  inline Message_PollCreationMessage() : Message_PollCreationMessage(nullptr) {}
  ~Message_PollCreationMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollCreationMessage(const Message_PollCreationMessage& from);
  Message_PollCreationMessage(Message_PollCreationMessage&& from) noexcept
    : Message_PollCreationMessage() {
    *this = ::std::move(from);
  }

  inline Message_PollCreationMessage& operator=(const Message_PollCreationMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollCreationMessage& operator=(Message_PollCreationMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollCreationMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollCreationMessage* internal_default_instance() {
    return reinterpret_cast<const Message_PollCreationMessage*>(
               &_Message_PollCreationMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    113;

  friend void swap(Message_PollCreationMessage& a, Message_PollCreationMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollCreationMessage* 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(Message_PollCreationMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollCreationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollCreationMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PollCreationMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PollCreationMessage& from) {
    Message_PollCreationMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PollCreationMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollCreationMessage";
  }
  protected:
  explicit Message_PollCreationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_PollCreationMessage_Option Option;

  // accessors -------------------------------------------------------

  enum : int {
    kOptionsFieldNumber = 3,
    kEncKeyFieldNumber = 1,
    kNameFieldNumber = 2,
    kContextInfoFieldNumber = 5,
    kSelectableOptionsCountFieldNumber = 4,
  };
  // repeated .proto.Message.PollCreationMessage.Option options = 3;
  int options_size() const;
  private:
  int _internal_options_size() const;
  public:
  void clear_options();
  ::proto::Message_PollCreationMessage_Option* mutable_options(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >*
      mutable_options();
  private:
  const ::proto::Message_PollCreationMessage_Option& _internal_options(int index) const;
  ::proto::Message_PollCreationMessage_Option* _internal_add_options();
  public:
  const ::proto::Message_PollCreationMessage_Option& options(int index) const;
  ::proto::Message_PollCreationMessage_Option* add_options();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >&
      options() const;

  // optional bytes encKey = 1;
  bool has_enckey() const;
  private:
  bool _internal_has_enckey() const;
  public:
  void clear_enckey();
  const std::string& enckey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enckey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enckey();
  PROTOBUF_NODISCARD std::string* release_enckey();
  void set_allocated_enckey(std::string* enckey);
  private:
  const std::string& _internal_enckey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enckey(const std::string& value);
  std::string* _internal_mutable_enckey();
  public:

  // optional 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:

  // optional .proto.ContextInfo contextInfo = 5;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint32 selectableOptionsCount = 4;
  bool has_selectableoptionscount() const;
  private:
  bool _internal_has_selectableoptionscount() const;
  public:
  void clear_selectableoptionscount();
  uint32_t selectableoptionscount() const;
  void set_selectableoptionscount(uint32_t value);
  private:
  uint32_t _internal_selectableoptionscount() const;
  void _internal_set_selectableoptionscount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PollCreationMessage)
 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< ::proto::Message_PollCreationMessage_Option > options_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enckey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
    ::proto::ContextInfo* contextinfo_;
    uint32_t selectableoptionscount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollEncValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollEncValue) */ {
 public:
  inline Message_PollEncValue() : Message_PollEncValue(nullptr) {}
  ~Message_PollEncValue() override;
  explicit PROTOBUF_CONSTEXPR Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollEncValue(const Message_PollEncValue& from);
  Message_PollEncValue(Message_PollEncValue&& from) noexcept
    : Message_PollEncValue() {
    *this = ::std::move(from);
  }

  inline Message_PollEncValue& operator=(const Message_PollEncValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollEncValue& operator=(Message_PollEncValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollEncValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollEncValue* internal_default_instance() {
    return reinterpret_cast<const Message_PollEncValue*>(
               &_Message_PollEncValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    114;

  friend void swap(Message_PollEncValue& a, Message_PollEncValue& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollEncValue* 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(Message_PollEncValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollEncValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PollEncValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PollEncValue& from) {
    Message_PollEncValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PollEncValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollEncValue";
  }
  protected:
  explicit Message_PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEncPayloadFieldNumber = 1,
    kEncIvFieldNumber = 2,
  };
  // optional bytes encPayload = 1;
  bool has_encpayload() const;
  private:
  bool _internal_has_encpayload() const;
  public:
  void clear_encpayload();
  const std::string& encpayload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encpayload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encpayload();
  PROTOBUF_NODISCARD std::string* release_encpayload();
  void set_allocated_encpayload(std::string* encpayload);
  private:
  const std::string& _internal_encpayload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value);
  std::string* _internal_mutable_encpayload();
  public:

  // optional bytes encIv = 2;
  bool has_enciv() const;
  private:
  bool _internal_has_enciv() const;
  public:
  void clear_enciv();
  const std::string& enciv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enciv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enciv();
  PROTOBUF_NODISCARD std::string* release_enciv();
  void set_allocated_enciv(std::string* enciv);
  private:
  const std::string& _internal_enciv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value);
  std::string* _internal_mutable_enciv();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PollEncValue)
 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 encpayload_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollUpdateMessageMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessageMetadata) */ {
 public:
  inline Message_PollUpdateMessageMetadata() : Message_PollUpdateMessageMetadata(nullptr) {}
  explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollUpdateMessageMetadata(const Message_PollUpdateMessageMetadata& from);
  Message_PollUpdateMessageMetadata(Message_PollUpdateMessageMetadata&& from) noexcept
    : Message_PollUpdateMessageMetadata() {
    *this = ::std::move(from);
  }

  inline Message_PollUpdateMessageMetadata& operator=(const Message_PollUpdateMessageMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollUpdateMessageMetadata& operator=(Message_PollUpdateMessageMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollUpdateMessageMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollUpdateMessageMetadata* internal_default_instance() {
    return reinterpret_cast<const Message_PollUpdateMessageMetadata*>(
               &_Message_PollUpdateMessageMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    115;

  friend void swap(Message_PollUpdateMessageMetadata& a, Message_PollUpdateMessageMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollUpdateMessageMetadata* 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(Message_PollUpdateMessageMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollUpdateMessageMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollUpdateMessageMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom;
  inline void CopyFrom(const Message_PollUpdateMessageMetadata& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(*this, from);
  }
  using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom;
  void MergeFrom(const Message_PollUpdateMessageMetadata& from) {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(*this, from);
  }
  public:

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollUpdateMessageMetadata";
  }
  protected:
  explicit Message_PollUpdateMessageMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessageMetadata)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
  };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollUpdateMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollUpdateMessage) */ {
 public:
  inline Message_PollUpdateMessage() : Message_PollUpdateMessage(nullptr) {}
  ~Message_PollUpdateMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollUpdateMessage(const Message_PollUpdateMessage& from);
  Message_PollUpdateMessage(Message_PollUpdateMessage&& from) noexcept
    : Message_PollUpdateMessage() {
    *this = ::std::move(from);
  }

  inline Message_PollUpdateMessage& operator=(const Message_PollUpdateMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollUpdateMessage& operator=(Message_PollUpdateMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollUpdateMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollUpdateMessage* internal_default_instance() {
    return reinterpret_cast<const Message_PollUpdateMessage*>(
               &_Message_PollUpdateMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    116;

  friend void swap(Message_PollUpdateMessage& a, Message_PollUpdateMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollUpdateMessage* 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(Message_PollUpdateMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollUpdateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollUpdateMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PollUpdateMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PollUpdateMessage& from) {
    Message_PollUpdateMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PollUpdateMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollUpdateMessage";
  }
  protected:
  explicit Message_PollUpdateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPollCreationMessageKeyFieldNumber = 1,
    kVoteFieldNumber = 2,
    kMetadataFieldNumber = 3,
    kSenderTimestampMsFieldNumber = 4,
  };
  // optional .proto.MessageKey pollCreationMessageKey = 1;
  bool has_pollcreationmessagekey() const;
  private:
  bool _internal_has_pollcreationmessagekey() const;
  public:
  void clear_pollcreationmessagekey();
  const ::proto::MessageKey& pollcreationmessagekey() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_pollcreationmessagekey();
  ::proto::MessageKey* mutable_pollcreationmessagekey();
  void set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey);
  private:
  const ::proto::MessageKey& _internal_pollcreationmessagekey() const;
  ::proto::MessageKey* _internal_mutable_pollcreationmessagekey();
  public:
  void unsafe_arena_set_allocated_pollcreationmessagekey(
      ::proto::MessageKey* pollcreationmessagekey);
  ::proto::MessageKey* unsafe_arena_release_pollcreationmessagekey();

  // optional .proto.Message.PollEncValue vote = 2;
  bool has_vote() const;
  private:
  bool _internal_has_vote() const;
  public:
  void clear_vote();
  const ::proto::Message_PollEncValue& vote() const;
  PROTOBUF_NODISCARD ::proto::Message_PollEncValue* release_vote();
  ::proto::Message_PollEncValue* mutable_vote();
  void set_allocated_vote(::proto::Message_PollEncValue* vote);
  private:
  const ::proto::Message_PollEncValue& _internal_vote() const;
  ::proto::Message_PollEncValue* _internal_mutable_vote();
  public:
  void unsafe_arena_set_allocated_vote(
      ::proto::Message_PollEncValue* vote);
  ::proto::Message_PollEncValue* unsafe_arena_release_vote();

  // optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
  bool has_metadata() const;
  private:
  bool _internal_has_metadata() const;
  public:
  void clear_metadata();
  const ::proto::Message_PollUpdateMessageMetadata& metadata() const;
  PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessageMetadata* release_metadata();
  ::proto::Message_PollUpdateMessageMetadata* mutable_metadata();
  void set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata);
  private:
  const ::proto::Message_PollUpdateMessageMetadata& _internal_metadata() const;
  ::proto::Message_PollUpdateMessageMetadata* _internal_mutable_metadata();
  public:
  void unsafe_arena_set_allocated_metadata(
      ::proto::Message_PollUpdateMessageMetadata* metadata);
  ::proto::Message_PollUpdateMessageMetadata* unsafe_arena_release_metadata();

  // optional int64 senderTimestampMs = 4;
  bool has_sendertimestampms() const;
  private:
  bool _internal_has_sendertimestampms() const;
  public:
  void clear_sendertimestampms();
  int64_t sendertimestampms() const;
  void set_sendertimestampms(int64_t value);
  private:
  int64_t _internal_sendertimestampms() const;
  void _internal_set_sendertimestampms(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PollUpdateMessage)
 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_;
    ::proto::MessageKey* pollcreationmessagekey_;
    ::proto::Message_PollEncValue* vote_;
    ::proto::Message_PollUpdateMessageMetadata* metadata_;
    int64_t sendertimestampms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_PollVoteMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.PollVoteMessage) */ {
 public:
  inline Message_PollVoteMessage() : Message_PollVoteMessage(nullptr) {}
  ~Message_PollVoteMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_PollVoteMessage(const Message_PollVoteMessage& from);
  Message_PollVoteMessage(Message_PollVoteMessage&& from) noexcept
    : Message_PollVoteMessage() {
    *this = ::std::move(from);
  }

  inline Message_PollVoteMessage& operator=(const Message_PollVoteMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_PollVoteMessage& operator=(Message_PollVoteMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_PollVoteMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_PollVoteMessage* internal_default_instance() {
    return reinterpret_cast<const Message_PollVoteMessage*>(
               &_Message_PollVoteMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    117;

  friend void swap(Message_PollVoteMessage& a, Message_PollVoteMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_PollVoteMessage* 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(Message_PollVoteMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_PollVoteMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_PollVoteMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_PollVoteMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_PollVoteMessage& from) {
    Message_PollVoteMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_PollVoteMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.PollVoteMessage";
  }
  protected:
  explicit Message_PollVoteMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSelectedOptionsFieldNumber = 1,
  };
  // repeated bytes selectedOptions = 1;
  int selectedoptions_size() const;
  private:
  int _internal_selectedoptions_size() const;
  public:
  void clear_selectedoptions();
  const std::string& selectedoptions(int index) const;
  std::string* mutable_selectedoptions(int index);
  void set_selectedoptions(int index, const std::string& value);
  void set_selectedoptions(int index, std::string&& value);
  void set_selectedoptions(int index, const char* value);
  void set_selectedoptions(int index, const void* value, size_t size);
  std::string* add_selectedoptions();
  void add_selectedoptions(const std::string& value);
  void add_selectedoptions(std::string&& value);
  void add_selectedoptions(const char* value);
  void add_selectedoptions(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& selectedoptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_selectedoptions();
  private:
  const std::string& _internal_selectedoptions(int index) const;
  std::string* _internal_add_selectedoptions();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.PollVoteMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> selectedoptions_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ProductMessage_CatalogSnapshot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.CatalogSnapshot) */ {
 public:
  inline Message_ProductMessage_CatalogSnapshot() : Message_ProductMessage_CatalogSnapshot(nullptr) {}
  ~Message_ProductMessage_CatalogSnapshot() override;
  explicit PROTOBUF_CONSTEXPR Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ProductMessage_CatalogSnapshot(const Message_ProductMessage_CatalogSnapshot& from);
  Message_ProductMessage_CatalogSnapshot(Message_ProductMessage_CatalogSnapshot&& from) noexcept
    : Message_ProductMessage_CatalogSnapshot() {
    *this = ::std::move(from);
  }

  inline Message_ProductMessage_CatalogSnapshot& operator=(const Message_ProductMessage_CatalogSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ProductMessage_CatalogSnapshot& operator=(Message_ProductMessage_CatalogSnapshot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ProductMessage_CatalogSnapshot& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ProductMessage_CatalogSnapshot* internal_default_instance() {
    return reinterpret_cast<const Message_ProductMessage_CatalogSnapshot*>(
               &_Message_ProductMessage_CatalogSnapshot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    118;

  friend void swap(Message_ProductMessage_CatalogSnapshot& a, Message_ProductMessage_CatalogSnapshot& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ProductMessage_CatalogSnapshot* 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(Message_ProductMessage_CatalogSnapshot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ProductMessage_CatalogSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ProductMessage_CatalogSnapshot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ProductMessage_CatalogSnapshot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ProductMessage_CatalogSnapshot& from) {
    Message_ProductMessage_CatalogSnapshot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ProductMessage_CatalogSnapshot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ProductMessage.CatalogSnapshot";
  }
  protected:
  explicit Message_ProductMessage_CatalogSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTitleFieldNumber = 2,
    kDescriptionFieldNumber = 3,
    kCatalogImageFieldNumber = 1,
  };
  // 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 string description = 3;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional .proto.Message.ImageMessage catalogImage = 1;
  bool has_catalogimage() const;
  private:
  bool _internal_has_catalogimage() const;
  public:
  void clear_catalogimage();
  const ::proto::Message_ImageMessage& catalogimage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_catalogimage();
  ::proto::Message_ImageMessage* mutable_catalogimage();
  void set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage);
  private:
  const ::proto::Message_ImageMessage& _internal_catalogimage() const;
  ::proto::Message_ImageMessage* _internal_mutable_catalogimage();
  public:
  void unsafe_arena_set_allocated_catalogimage(
      ::proto::Message_ImageMessage* catalogimage);
  ::proto::Message_ImageMessage* unsafe_arena_release_catalogimage();

  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.CatalogSnapshot)
 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 title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::proto::Message_ImageMessage* catalogimage_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ProductMessage_ProductSnapshot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage.ProductSnapshot) */ {
 public:
  inline Message_ProductMessage_ProductSnapshot() : Message_ProductMessage_ProductSnapshot(nullptr) {}
  ~Message_ProductMessage_ProductSnapshot() override;
  explicit PROTOBUF_CONSTEXPR Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ProductMessage_ProductSnapshot(const Message_ProductMessage_ProductSnapshot& from);
  Message_ProductMessage_ProductSnapshot(Message_ProductMessage_ProductSnapshot&& from) noexcept
    : Message_ProductMessage_ProductSnapshot() {
    *this = ::std::move(from);
  }

  inline Message_ProductMessage_ProductSnapshot& operator=(const Message_ProductMessage_ProductSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ProductMessage_ProductSnapshot& operator=(Message_ProductMessage_ProductSnapshot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ProductMessage_ProductSnapshot& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ProductMessage_ProductSnapshot* internal_default_instance() {
    return reinterpret_cast<const Message_ProductMessage_ProductSnapshot*>(
               &_Message_ProductMessage_ProductSnapshot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    119;

  friend void swap(Message_ProductMessage_ProductSnapshot& a, Message_ProductMessage_ProductSnapshot& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ProductMessage_ProductSnapshot* 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(Message_ProductMessage_ProductSnapshot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ProductMessage_ProductSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ProductMessage_ProductSnapshot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ProductMessage_ProductSnapshot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ProductMessage_ProductSnapshot& from) {
    Message_ProductMessage_ProductSnapshot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ProductMessage_ProductSnapshot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ProductMessage.ProductSnapshot";
  }
  protected:
  explicit Message_ProductMessage_ProductSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProductIdFieldNumber = 2,
    kTitleFieldNumber = 3,
    kDescriptionFieldNumber = 4,
    kCurrencyCodeFieldNumber = 5,
    kRetailerIdFieldNumber = 7,
    kUrlFieldNumber = 8,
    kFirstImageIdFieldNumber = 11,
    kProductImageFieldNumber = 1,
    kPriceAmount1000FieldNumber = 6,
    kSalePriceAmount1000FieldNumber = 12,
    kProductImageCountFieldNumber = 9,
  };
  // optional string productId = 2;
  bool has_productid() const;
  private:
  bool _internal_has_productid() const;
  public:
  void clear_productid();
  const std::string& productid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_productid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_productid();
  PROTOBUF_NODISCARD std::string* release_productid();
  void set_allocated_productid(std::string* productid);
  private:
  const std::string& _internal_productid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_productid(const std::string& value);
  std::string* _internal_mutable_productid();
  public:

  // optional string title = 3;
  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 string description = 4;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional string currencyCode = 5;
  bool has_currencycode() const;
  private:
  bool _internal_has_currencycode() const;
  public:
  void clear_currencycode();
  const std::string& currencycode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_currencycode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_currencycode();
  PROTOBUF_NODISCARD std::string* release_currencycode();
  void set_allocated_currencycode(std::string* currencycode);
  private:
  const std::string& _internal_currencycode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
  std::string* _internal_mutable_currencycode();
  public:

  // optional string retailerId = 7;
  bool has_retailerid() const;
  private:
  bool _internal_has_retailerid() const;
  public:
  void clear_retailerid();
  const std::string& retailerid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_retailerid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_retailerid();
  PROTOBUF_NODISCARD std::string* release_retailerid();
  void set_allocated_retailerid(std::string* retailerid);
  private:
  const std::string& _internal_retailerid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_retailerid(const std::string& value);
  std::string* _internal_mutable_retailerid();
  public:

  // optional string url = 8;
  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 firstImageId = 11;
  bool has_firstimageid() const;
  private:
  bool _internal_has_firstimageid() const;
  public:
  void clear_firstimageid();
  const std::string& firstimageid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_firstimageid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_firstimageid();
  PROTOBUF_NODISCARD std::string* release_firstimageid();
  void set_allocated_firstimageid(std::string* firstimageid);
  private:
  const std::string& _internal_firstimageid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstimageid(const std::string& value);
  std::string* _internal_mutable_firstimageid();
  public:

  // optional .proto.Message.ImageMessage productImage = 1;
  bool has_productimage() const;
  private:
  bool _internal_has_productimage() const;
  public:
  void clear_productimage();
  const ::proto::Message_ImageMessage& productimage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_productimage();
  ::proto::Message_ImageMessage* mutable_productimage();
  void set_allocated_productimage(::proto::Message_ImageMessage* productimage);
  private:
  const ::proto::Message_ImageMessage& _internal_productimage() const;
  ::proto::Message_ImageMessage* _internal_mutable_productimage();
  public:
  void unsafe_arena_set_allocated_productimage(
      ::proto::Message_ImageMessage* productimage);
  ::proto::Message_ImageMessage* unsafe_arena_release_productimage();

  // optional int64 priceAmount1000 = 6;
  bool has_priceamount1000() const;
  private:
  bool _internal_has_priceamount1000() const;
  public:
  void clear_priceamount1000();
  int64_t priceamount1000() const;
  void set_priceamount1000(int64_t value);
  private:
  int64_t _internal_priceamount1000() const;
  void _internal_set_priceamount1000(int64_t value);
  public:

  // optional int64 salePriceAmount1000 = 12;
  bool has_salepriceamount1000() const;
  private:
  bool _internal_has_salepriceamount1000() const;
  public:
  void clear_salepriceamount1000();
  int64_t salepriceamount1000() const;
  void set_salepriceamount1000(int64_t value);
  private:
  int64_t _internal_salepriceamount1000() const;
  void _internal_set_salepriceamount1000(int64_t value);
  public:

  // optional uint32 productImageCount = 9;
  bool has_productimagecount() const;
  private:
  bool _internal_has_productimagecount() const;
  public:
  void clear_productimagecount();
  uint32_t productimagecount() const;
  void set_productimagecount(uint32_t value);
  private:
  uint32_t _internal_productimagecount() const;
  void _internal_set_productimagecount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage.ProductSnapshot)
 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 productid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currencycode_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr retailerid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstimageid_;
    ::proto::Message_ImageMessage* productimage_;
    int64_t priceamount1000_;
    int64_t salepriceamount1000_;
    uint32_t productimagecount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ProductMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProductMessage) */ {
 public:
  inline Message_ProductMessage() : Message_ProductMessage(nullptr) {}
  ~Message_ProductMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ProductMessage(const Message_ProductMessage& from);
  Message_ProductMessage(Message_ProductMessage&& from) noexcept
    : Message_ProductMessage() {
    *this = ::std::move(from);
  }

  inline Message_ProductMessage& operator=(const Message_ProductMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ProductMessage& operator=(Message_ProductMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ProductMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ProductMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ProductMessage*>(
               &_Message_ProductMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    120;

  friend void swap(Message_ProductMessage& a, Message_ProductMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ProductMessage* 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(Message_ProductMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ProductMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ProductMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ProductMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ProductMessage& from) {
    Message_ProductMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ProductMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ProductMessage";
  }
  protected:
  explicit Message_ProductMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ProductMessage_CatalogSnapshot CatalogSnapshot;
  typedef Message_ProductMessage_ProductSnapshot ProductSnapshot;

  // accessors -------------------------------------------------------

  enum : int {
    kBusinessOwnerJidFieldNumber = 2,
    kBodyFieldNumber = 5,
    kFooterFieldNumber = 6,
    kProductFieldNumber = 1,
    kCatalogFieldNumber = 4,
    kContextInfoFieldNumber = 17,
  };
  // optional string businessOwnerJid = 2;
  bool has_businessownerjid() const;
  private:
  bool _internal_has_businessownerjid() const;
  public:
  void clear_businessownerjid();
  const std::string& businessownerjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_businessownerjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_businessownerjid();
  PROTOBUF_NODISCARD std::string* release_businessownerjid();
  void set_allocated_businessownerjid(std::string* businessownerjid);
  private:
  const std::string& _internal_businessownerjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_businessownerjid(const std::string& value);
  std::string* _internal_mutable_businessownerjid();
  public:

  // optional string body = 5;
  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 string footer = 6;
  bool has_footer() const;
  private:
  bool _internal_has_footer() const;
  public:
  void clear_footer();
  const std::string& footer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_footer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_footer();
  PROTOBUF_NODISCARD std::string* release_footer();
  void set_allocated_footer(std::string* footer);
  private:
  const std::string& _internal_footer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_footer(const std::string& value);
  std::string* _internal_mutable_footer();
  public:

  // optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
  bool has_product() const;
  private:
  bool _internal_has_product() const;
  public:
  void clear_product();
  const ::proto::Message_ProductMessage_ProductSnapshot& product() const;
  PROTOBUF_NODISCARD ::proto::Message_ProductMessage_ProductSnapshot* release_product();
  ::proto::Message_ProductMessage_ProductSnapshot* mutable_product();
  void set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product);
  private:
  const ::proto::Message_ProductMessage_ProductSnapshot& _internal_product() const;
  ::proto::Message_ProductMessage_ProductSnapshot* _internal_mutable_product();
  public:
  void unsafe_arena_set_allocated_product(
      ::proto::Message_ProductMessage_ProductSnapshot* product);
  ::proto::Message_ProductMessage_ProductSnapshot* unsafe_arena_release_product();

  // optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
  bool has_catalog() const;
  private:
  bool _internal_has_catalog() const;
  public:
  void clear_catalog();
  const ::proto::Message_ProductMessage_CatalogSnapshot& catalog() const;
  PROTOBUF_NODISCARD ::proto::Message_ProductMessage_CatalogSnapshot* release_catalog();
  ::proto::Message_ProductMessage_CatalogSnapshot* mutable_catalog();
  void set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog);
  private:
  const ::proto::Message_ProductMessage_CatalogSnapshot& _internal_catalog() const;
  ::proto::Message_ProductMessage_CatalogSnapshot* _internal_mutable_catalog();
  public:
  void unsafe_arena_set_allocated_catalog(
      ::proto::Message_ProductMessage_CatalogSnapshot* catalog);
  ::proto::Message_ProductMessage_CatalogSnapshot* unsafe_arena_release_catalog();

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // @@protoc_insertion_point(class_scope:proto.Message.ProductMessage)
 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 businessownerjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr footer_;
    ::proto::Message_ProductMessage_ProductSnapshot* product_;
    ::proto::Message_ProductMessage_CatalogSnapshot* catalog_;
    ::proto::ContextInfo* contextinfo_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ProtocolMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ProtocolMessage) */ {
 public:
  inline Message_ProtocolMessage() : Message_ProtocolMessage(nullptr) {}
  ~Message_ProtocolMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ProtocolMessage(const Message_ProtocolMessage& from);
  Message_ProtocolMessage(Message_ProtocolMessage&& from) noexcept
    : Message_ProtocolMessage() {
    *this = ::std::move(from);
  }

  inline Message_ProtocolMessage& operator=(const Message_ProtocolMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ProtocolMessage& operator=(Message_ProtocolMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ProtocolMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ProtocolMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ProtocolMessage*>(
               &_Message_ProtocolMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    121;

  friend void swap(Message_ProtocolMessage& a, Message_ProtocolMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ProtocolMessage* 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(Message_ProtocolMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ProtocolMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ProtocolMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ProtocolMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ProtocolMessage& from) {
    Message_ProtocolMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ProtocolMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ProtocolMessage";
  }
  protected:
  explicit Message_ProtocolMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_ProtocolMessage_Type Type;
  static constexpr Type REVOKE =
    Message_ProtocolMessage_Type_REVOKE;
  static constexpr Type EPHEMERAL_SETTING =
    Message_ProtocolMessage_Type_EPHEMERAL_SETTING;
  static constexpr Type EPHEMERAL_SYNC_RESPONSE =
    Message_ProtocolMessage_Type_EPHEMERAL_SYNC_RESPONSE;
  static constexpr Type HISTORY_SYNC_NOTIFICATION =
    Message_ProtocolMessage_Type_HISTORY_SYNC_NOTIFICATION;
  static constexpr Type APP_STATE_SYNC_KEY_SHARE =
    Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_SHARE;
  static constexpr Type APP_STATE_SYNC_KEY_REQUEST =
    Message_ProtocolMessage_Type_APP_STATE_SYNC_KEY_REQUEST;
  static constexpr Type MSG_FANOUT_BACKFILL_REQUEST =
    Message_ProtocolMessage_Type_MSG_FANOUT_BACKFILL_REQUEST;
  static constexpr Type INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC =
    Message_ProtocolMessage_Type_INITIAL_SECURITY_NOTIFICATION_SETTING_SYNC;
  static constexpr Type APP_STATE_FATAL_EXCEPTION_NOTIFICATION =
    Message_ProtocolMessage_Type_APP_STATE_FATAL_EXCEPTION_NOTIFICATION;
  static constexpr Type SHARE_PHONE_NUMBER =
    Message_ProtocolMessage_Type_SHARE_PHONE_NUMBER;
  static constexpr Type REQUEST_MEDIA_UPLOAD_MESSAGE =
    Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_MESSAGE;
  static constexpr Type REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE =
    Message_ProtocolMessage_Type_REQUEST_MEDIA_UPLOAD_RESPONSE_MESSAGE;
  static inline bool Type_IsValid(int value) {
    return Message_ProtocolMessage_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Message_ProtocolMessage_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Message_ProtocolMessage_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Message_ProtocolMessage_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Message_ProtocolMessage_Type_descriptor();
  }
  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 Message_ProtocolMessage_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return Message_ProtocolMessage_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kHistorySyncNotificationFieldNumber = 6,
    kAppStateSyncKeyShareFieldNumber = 7,
    kAppStateSyncKeyRequestFieldNumber = 8,
    kInitialSecurityNotificationSettingSyncFieldNumber = 9,
    kAppStateFatalExceptionNotificationFieldNumber = 10,
    kDisappearingModeFieldNumber = 11,
    kRequestMediaUploadMessageFieldNumber = 12,
    kRequestMediaUploadResponseMessageFieldNumber = 13,
    kTypeFieldNumber = 2,
    kEphemeralExpirationFieldNumber = 4,
    kEphemeralSettingTimestampFieldNumber = 5,
  };
  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
  bool has_historysyncnotification() const;
  private:
  bool _internal_has_historysyncnotification() const;
  public:
  void clear_historysyncnotification();
  const ::proto::Message_HistorySyncNotification& historysyncnotification() const;
  PROTOBUF_NODISCARD ::proto::Message_HistorySyncNotification* release_historysyncnotification();
  ::proto::Message_HistorySyncNotification* mutable_historysyncnotification();
  void set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification);
  private:
  const ::proto::Message_HistorySyncNotification& _internal_historysyncnotification() const;
  ::proto::Message_HistorySyncNotification* _internal_mutable_historysyncnotification();
  public:
  void unsafe_arena_set_allocated_historysyncnotification(
      ::proto::Message_HistorySyncNotification* historysyncnotification);
  ::proto::Message_HistorySyncNotification* unsafe_arena_release_historysyncnotification();

  // optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
  bool has_appstatesynckeyshare() const;
  private:
  bool _internal_has_appstatesynckeyshare() const;
  public:
  void clear_appstatesynckeyshare();
  const ::proto::Message_AppStateSyncKeyShare& appstatesynckeyshare() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyShare* release_appstatesynckeyshare();
  ::proto::Message_AppStateSyncKeyShare* mutable_appstatesynckeyshare();
  void set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare);
  private:
  const ::proto::Message_AppStateSyncKeyShare& _internal_appstatesynckeyshare() const;
  ::proto::Message_AppStateSyncKeyShare* _internal_mutable_appstatesynckeyshare();
  public:
  void unsafe_arena_set_allocated_appstatesynckeyshare(
      ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare);
  ::proto::Message_AppStateSyncKeyShare* unsafe_arena_release_appstatesynckeyshare();

  // optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
  bool has_appstatesynckeyrequest() const;
  private:
  bool _internal_has_appstatesynckeyrequest() const;
  public:
  void clear_appstatesynckeyrequest();
  const ::proto::Message_AppStateSyncKeyRequest& appstatesynckeyrequest() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateSyncKeyRequest* release_appstatesynckeyrequest();
  ::proto::Message_AppStateSyncKeyRequest* mutable_appstatesynckeyrequest();
  void set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest);
  private:
  const ::proto::Message_AppStateSyncKeyRequest& _internal_appstatesynckeyrequest() const;
  ::proto::Message_AppStateSyncKeyRequest* _internal_mutable_appstatesynckeyrequest();
  public:
  void unsafe_arena_set_allocated_appstatesynckeyrequest(
      ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest);
  ::proto::Message_AppStateSyncKeyRequest* unsafe_arena_release_appstatesynckeyrequest();

  // optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
  bool has_initialsecuritynotificationsettingsync() const;
  private:
  bool _internal_has_initialsecuritynotificationsettingsync() const;
  public:
  void clear_initialsecuritynotificationsettingsync();
  const ::proto::Message_InitialSecurityNotificationSettingSync& initialsecuritynotificationsettingsync() const;
  PROTOBUF_NODISCARD ::proto::Message_InitialSecurityNotificationSettingSync* release_initialsecuritynotificationsettingsync();
  ::proto::Message_InitialSecurityNotificationSettingSync* mutable_initialsecuritynotificationsettingsync();
  void set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync);
  private:
  const ::proto::Message_InitialSecurityNotificationSettingSync& _internal_initialsecuritynotificationsettingsync() const;
  ::proto::Message_InitialSecurityNotificationSettingSync* _internal_mutable_initialsecuritynotificationsettingsync();
  public:
  void unsafe_arena_set_allocated_initialsecuritynotificationsettingsync(
      ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync);
  ::proto::Message_InitialSecurityNotificationSettingSync* unsafe_arena_release_initialsecuritynotificationsettingsync();

  // optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
  bool has_appstatefatalexceptionnotification() const;
  private:
  bool _internal_has_appstatefatalexceptionnotification() const;
  public:
  void clear_appstatefatalexceptionnotification();
  const ::proto::Message_AppStateFatalExceptionNotification& appstatefatalexceptionnotification() const;
  PROTOBUF_NODISCARD ::proto::Message_AppStateFatalExceptionNotification* release_appstatefatalexceptionnotification();
  ::proto::Message_AppStateFatalExceptionNotification* mutable_appstatefatalexceptionnotification();
  void set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification);
  private:
  const ::proto::Message_AppStateFatalExceptionNotification& _internal_appstatefatalexceptionnotification() const;
  ::proto::Message_AppStateFatalExceptionNotification* _internal_mutable_appstatefatalexceptionnotification();
  public:
  void unsafe_arena_set_allocated_appstatefatalexceptionnotification(
      ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification);
  ::proto::Message_AppStateFatalExceptionNotification* unsafe_arena_release_appstatefatalexceptionnotification();

  // optional .proto.DisappearingMode disappearingMode = 11;
  bool has_disappearingmode() const;
  private:
  bool _internal_has_disappearingmode() const;
  public:
  void clear_disappearingmode();
  const ::proto::DisappearingMode& disappearingmode() const;
  PROTOBUF_NODISCARD ::proto::DisappearingMode* release_disappearingmode();
  ::proto::DisappearingMode* mutable_disappearingmode();
  void set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode);
  private:
  const ::proto::DisappearingMode& _internal_disappearingmode() const;
  ::proto::DisappearingMode* _internal_mutable_disappearingmode();
  public:
  void unsafe_arena_set_allocated_disappearingmode(
      ::proto::DisappearingMode* disappearingmode);
  ::proto::DisappearingMode* unsafe_arena_release_disappearingmode();

  // optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
  bool has_requestmediauploadmessage() const;
  private:
  bool _internal_has_requestmediauploadmessage() const;
  public:
  void clear_requestmediauploadmessage();
  const ::proto::Message_RequestMediaUploadMessage& requestmediauploadmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadMessage* release_requestmediauploadmessage();
  ::proto::Message_RequestMediaUploadMessage* mutable_requestmediauploadmessage();
  void set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage);
  private:
  const ::proto::Message_RequestMediaUploadMessage& _internal_requestmediauploadmessage() const;
  ::proto::Message_RequestMediaUploadMessage* _internal_mutable_requestmediauploadmessage();
  public:
  void unsafe_arena_set_allocated_requestmediauploadmessage(
      ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage);
  ::proto::Message_RequestMediaUploadMessage* unsafe_arena_release_requestmediauploadmessage();

  // optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
  bool has_requestmediauploadresponsemessage() const;
  private:
  bool _internal_has_requestmediauploadresponsemessage() const;
  public:
  void clear_requestmediauploadresponsemessage();
  const ::proto::Message_RequestMediaUploadResponseMessage& requestmediauploadresponsemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_RequestMediaUploadResponseMessage* release_requestmediauploadresponsemessage();
  ::proto::Message_RequestMediaUploadResponseMessage* mutable_requestmediauploadresponsemessage();
  void set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage);
  private:
  const ::proto::Message_RequestMediaUploadResponseMessage& _internal_requestmediauploadresponsemessage() const;
  ::proto::Message_RequestMediaUploadResponseMessage* _internal_mutable_requestmediauploadresponsemessage();
  public:
  void unsafe_arena_set_allocated_requestmediauploadresponsemessage(
      ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage);
  ::proto::Message_RequestMediaUploadResponseMessage* unsafe_arena_release_requestmediauploadresponsemessage();

  // optional .proto.Message.ProtocolMessage.Type type = 2;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::proto::Message_ProtocolMessage_Type type() const;
  void set_type(::proto::Message_ProtocolMessage_Type value);
  private:
  ::proto::Message_ProtocolMessage_Type _internal_type() const;
  void _internal_set_type(::proto::Message_ProtocolMessage_Type value);
  public:

  // optional uint32 ephemeralExpiration = 4;
  bool has_ephemeralexpiration() const;
  private:
  bool _internal_has_ephemeralexpiration() const;
  public:
  void clear_ephemeralexpiration();
  uint32_t ephemeralexpiration() const;
  void set_ephemeralexpiration(uint32_t value);
  private:
  uint32_t _internal_ephemeralexpiration() const;
  void _internal_set_ephemeralexpiration(uint32_t value);
  public:

  // optional int64 ephemeralSettingTimestamp = 5;
  bool has_ephemeralsettingtimestamp() const;
  private:
  bool _internal_has_ephemeralsettingtimestamp() const;
  public:
  void clear_ephemeralsettingtimestamp();
  int64_t ephemeralsettingtimestamp() const;
  void set_ephemeralsettingtimestamp(int64_t value);
  private:
  int64_t _internal_ephemeralsettingtimestamp() const;
  void _internal_set_ephemeralsettingtimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ProtocolMessage)
 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_;
    ::proto::MessageKey* key_;
    ::proto::Message_HistorySyncNotification* historysyncnotification_;
    ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare_;
    ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest_;
    ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync_;
    ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification_;
    ::proto::DisappearingMode* disappearingmode_;
    ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage_;
    ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage_;
    int type_;
    uint32_t ephemeralexpiration_;
    int64_t ephemeralsettingtimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_ReactionMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.ReactionMessage) */ {
 public:
  inline Message_ReactionMessage() : Message_ReactionMessage(nullptr) {}
  ~Message_ReactionMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_ReactionMessage(const Message_ReactionMessage& from);
  Message_ReactionMessage(Message_ReactionMessage&& from) noexcept
    : Message_ReactionMessage() {
    *this = ::std::move(from);
  }

  inline Message_ReactionMessage& operator=(const Message_ReactionMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_ReactionMessage& operator=(Message_ReactionMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_ReactionMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_ReactionMessage* internal_default_instance() {
    return reinterpret_cast<const Message_ReactionMessage*>(
               &_Message_ReactionMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    122;

  friend void swap(Message_ReactionMessage& a, Message_ReactionMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_ReactionMessage* 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(Message_ReactionMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_ReactionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_ReactionMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_ReactionMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_ReactionMessage& from) {
    Message_ReactionMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_ReactionMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.ReactionMessage";
  }
  protected:
  explicit Message_ReactionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 2,
    kGroupingKeyFieldNumber = 3,
    kKeyFieldNumber = 1,
    kSenderTimestampMsFieldNumber = 4,
  };
  // optional string text = 2;
  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:

  // optional string groupingKey = 3;
  bool has_groupingkey() const;
  private:
  bool _internal_has_groupingkey() const;
  public:
  void clear_groupingkey();
  const std::string& groupingkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupingkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupingkey();
  PROTOBUF_NODISCARD std::string* release_groupingkey();
  void set_allocated_groupingkey(std::string* groupingkey);
  private:
  const std::string& _internal_groupingkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value);
  std::string* _internal_mutable_groupingkey();
  public:

  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional int64 senderTimestampMs = 4;
  bool has_sendertimestampms() const;
  private:
  bool _internal_has_sendertimestampms() const;
  public:
  void clear_sendertimestampms();
  int64_t sendertimestampms() const;
  void set_sendertimestampms(int64_t value);
  private:
  int64_t _internal_sendertimestampms() const;
  void _internal_set_sendertimestampms(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.ReactionMessage)
 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 text_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_;
    ::proto::MessageKey* key_;
    int64_t sendertimestampms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_RequestMediaUploadMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadMessage) */ {
 public:
  inline Message_RequestMediaUploadMessage() : Message_RequestMediaUploadMessage(nullptr) {}
  ~Message_RequestMediaUploadMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_RequestMediaUploadMessage(const Message_RequestMediaUploadMessage& from);
  Message_RequestMediaUploadMessage(Message_RequestMediaUploadMessage&& from) noexcept
    : Message_RequestMediaUploadMessage() {
    *this = ::std::move(from);
  }

  inline Message_RequestMediaUploadMessage& operator=(const Message_RequestMediaUploadMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_RequestMediaUploadMessage& operator=(Message_RequestMediaUploadMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_RequestMediaUploadMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_RequestMediaUploadMessage* internal_default_instance() {
    return reinterpret_cast<const Message_RequestMediaUploadMessage*>(
               &_Message_RequestMediaUploadMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    123;

  friend void swap(Message_RequestMediaUploadMessage& a, Message_RequestMediaUploadMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_RequestMediaUploadMessage* 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(Message_RequestMediaUploadMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_RequestMediaUploadMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_RequestMediaUploadMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_RequestMediaUploadMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_RequestMediaUploadMessage& from) {
    Message_RequestMediaUploadMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_RequestMediaUploadMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.RequestMediaUploadMessage";
  }
  protected:
  explicit Message_RequestMediaUploadMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFileSha256FieldNumber = 1,
    kRmrSourceFieldNumber = 2,
  };
  // repeated string fileSha256 = 1;
  int filesha256_size() const;
  private:
  int _internal_filesha256_size() const;
  public:
  void clear_filesha256();
  const std::string& filesha256(int index) const;
  std::string* mutable_filesha256(int index);
  void set_filesha256(int index, const std::string& value);
  void set_filesha256(int index, std::string&& value);
  void set_filesha256(int index, const char* value);
  void set_filesha256(int index, const char* value, size_t size);
  std::string* add_filesha256();
  void add_filesha256(const std::string& value);
  void add_filesha256(std::string&& value);
  void add_filesha256(const char* value);
  void add_filesha256(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& filesha256() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_filesha256();
  private:
  const std::string& _internal_filesha256(int index) const;
  std::string* _internal_add_filesha256();
  public:

  // optional .proto.Message.RmrSource rmrSource = 2;
  bool has_rmrsource() const;
  private:
  bool _internal_has_rmrsource() const;
  public:
  void clear_rmrsource();
  ::proto::Message_RmrSource rmrsource() const;
  void set_rmrsource(::proto::Message_RmrSource value);
  private:
  ::proto::Message_RmrSource _internal_rmrsource() const;
  void _internal_set_rmrsource(::proto::Message_RmrSource value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadMessage)
 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> filesha256_;
    int rmrsource_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult) */ {
 public:
  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(nullptr) {}
  ~Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() override;
  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from);
  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept
    : Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult() {
    *this = ::std::move(from);
  }

  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& operator=(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* internal_default_instance() {
    return reinterpret_cast<const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult*>(
               &_Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    124;

  friend void swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& a, Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* 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(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& from) {
    Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult";
  }
  protected:
  explicit Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFileSha256FieldNumber = 1,
    kStickerMessageFieldNumber = 3,
    kMediaUploadResultFieldNumber = 2,
  };
  // optional string fileSha256 = 1;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional .proto.Message.StickerMessage stickerMessage = 3;
  bool has_stickermessage() const;
  private:
  bool _internal_has_stickermessage() const;
  public:
  void clear_stickermessage();
  const ::proto::Message_StickerMessage& stickermessage() const;
  PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage();
  ::proto::Message_StickerMessage* mutable_stickermessage();
  void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage);
  private:
  const ::proto::Message_StickerMessage& _internal_stickermessage() const;
  ::proto::Message_StickerMessage* _internal_mutable_stickermessage();
  public:
  void unsafe_arena_set_allocated_stickermessage(
      ::proto::Message_StickerMessage* stickermessage);
  ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage();

  // optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
  bool has_mediauploadresult() const;
  private:
  bool _internal_has_mediauploadresult() const;
  public:
  void clear_mediauploadresult();
  ::proto::MediaRetryNotification_ResultType mediauploadresult() const;
  void set_mediauploadresult(::proto::MediaRetryNotification_ResultType value);
  private:
  ::proto::MediaRetryNotification_ResultType _internal_mediauploadresult() const;
  void _internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult)
 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 filesha256_;
    ::proto::Message_StickerMessage* stickermessage_;
    int mediauploadresult_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_RequestMediaUploadResponseMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestMediaUploadResponseMessage) */ {
 public:
  inline Message_RequestMediaUploadResponseMessage() : Message_RequestMediaUploadResponseMessage(nullptr) {}
  ~Message_RequestMediaUploadResponseMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_RequestMediaUploadResponseMessage(const Message_RequestMediaUploadResponseMessage& from);
  Message_RequestMediaUploadResponseMessage(Message_RequestMediaUploadResponseMessage&& from) noexcept
    : Message_RequestMediaUploadResponseMessage() {
    *this = ::std::move(from);
  }

  inline Message_RequestMediaUploadResponseMessage& operator=(const Message_RequestMediaUploadResponseMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_RequestMediaUploadResponseMessage& operator=(Message_RequestMediaUploadResponseMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_RequestMediaUploadResponseMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_RequestMediaUploadResponseMessage* internal_default_instance() {
    return reinterpret_cast<const Message_RequestMediaUploadResponseMessage*>(
               &_Message_RequestMediaUploadResponseMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    125;

  friend void swap(Message_RequestMediaUploadResponseMessage& a, Message_RequestMediaUploadResponseMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_RequestMediaUploadResponseMessage* 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(Message_RequestMediaUploadResponseMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_RequestMediaUploadResponseMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_RequestMediaUploadResponseMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_RequestMediaUploadResponseMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_RequestMediaUploadResponseMessage& from) {
    Message_RequestMediaUploadResponseMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_RequestMediaUploadResponseMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.RequestMediaUploadResponseMessage";
  }
  protected:
  explicit Message_RequestMediaUploadResponseMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult RequestMediaUploadResult;

  // accessors -------------------------------------------------------

  enum : int {
    kReuploadResultFieldNumber = 3,
    kStanzaIdFieldNumber = 2,
    kRmrSourceFieldNumber = 1,
  };
  // repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
  int reuploadresult_size() const;
  private:
  int _internal_reuploadresult_size() const;
  public:
  void clear_reuploadresult();
  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* mutable_reuploadresult(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >*
      mutable_reuploadresult();
  private:
  const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& _internal_reuploadresult(int index) const;
  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _internal_add_reuploadresult();
  public:
  const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& reuploadresult(int index) const;
  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* add_reuploadresult();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >&
      reuploadresult() const;

  // optional string stanzaId = 2;
  bool has_stanzaid() const;
  private:
  bool _internal_has_stanzaid() const;
  public:
  void clear_stanzaid();
  const std::string& stanzaid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stanzaid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stanzaid();
  PROTOBUF_NODISCARD std::string* release_stanzaid();
  void set_allocated_stanzaid(std::string* stanzaid);
  private:
  const std::string& _internal_stanzaid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
  std::string* _internal_mutable_stanzaid();
  public:

  // optional .proto.Message.RmrSource rmrSource = 1;
  bool has_rmrsource() const;
  private:
  bool _internal_has_rmrsource() const;
  public:
  void clear_rmrsource();
  ::proto::Message_RmrSource rmrsource() const;
  void set_rmrsource(::proto::Message_RmrSource value);
  private:
  ::proto::Message_RmrSource _internal_rmrsource() const;
  void _internal_set_rmrsource(::proto::Message_RmrSource value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.RequestMediaUploadResponseMessage)
 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< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult > reuploadresult_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stanzaid_;
    int rmrsource_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_RequestPaymentMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPaymentMessage) */ {
 public:
  inline Message_RequestPaymentMessage() : Message_RequestPaymentMessage(nullptr) {}
  ~Message_RequestPaymentMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_RequestPaymentMessage(const Message_RequestPaymentMessage& from);
  Message_RequestPaymentMessage(Message_RequestPaymentMessage&& from) noexcept
    : Message_RequestPaymentMessage() {
    *this = ::std::move(from);
  }

  inline Message_RequestPaymentMessage& operator=(const Message_RequestPaymentMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_RequestPaymentMessage& operator=(Message_RequestPaymentMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_RequestPaymentMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_RequestPaymentMessage* internal_default_instance() {
    return reinterpret_cast<const Message_RequestPaymentMessage*>(
               &_Message_RequestPaymentMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    126;

  friend void swap(Message_RequestPaymentMessage& a, Message_RequestPaymentMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_RequestPaymentMessage* 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(Message_RequestPaymentMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_RequestPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_RequestPaymentMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_RequestPaymentMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_RequestPaymentMessage& from) {
    Message_RequestPaymentMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_RequestPaymentMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.RequestPaymentMessage";
  }
  protected:
  explicit Message_RequestPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCurrencyCodeIso4217FieldNumber = 1,
    kRequestFromFieldNumber = 3,
    kNoteMessageFieldNumber = 4,
    kAmountFieldNumber = 6,
    kBackgroundFieldNumber = 7,
    kAmount1000FieldNumber = 2,
    kExpiryTimestampFieldNumber = 5,
  };
  // optional string currencyCodeIso4217 = 1;
  bool has_currencycodeiso4217() const;
  private:
  bool _internal_has_currencycodeiso4217() const;
  public:
  void clear_currencycodeiso4217();
  const std::string& currencycodeiso4217() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_currencycodeiso4217(ArgT0&& arg0, ArgT... args);
  std::string* mutable_currencycodeiso4217();
  PROTOBUF_NODISCARD std::string* release_currencycodeiso4217();
  void set_allocated_currencycodeiso4217(std::string* currencycodeiso4217);
  private:
  const std::string& _internal_currencycodeiso4217() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycodeiso4217(const std::string& value);
  std::string* _internal_mutable_currencycodeiso4217();
  public:

  // optional string requestFrom = 3;
  bool has_requestfrom() const;
  private:
  bool _internal_has_requestfrom() const;
  public:
  void clear_requestfrom();
  const std::string& requestfrom() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_requestfrom(ArgT0&& arg0, ArgT... args);
  std::string* mutable_requestfrom();
  PROTOBUF_NODISCARD std::string* release_requestfrom();
  void set_allocated_requestfrom(std::string* requestfrom);
  private:
  const std::string& _internal_requestfrom() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_requestfrom(const std::string& value);
  std::string* _internal_mutable_requestfrom();
  public:

  // optional .proto.Message noteMessage = 4;
  bool has_notemessage() const;
  private:
  bool _internal_has_notemessage() const;
  public:
  void clear_notemessage();
  const ::proto::Message& notemessage() const;
  PROTOBUF_NODISCARD ::proto::Message* release_notemessage();
  ::proto::Message* mutable_notemessage();
  void set_allocated_notemessage(::proto::Message* notemessage);
  private:
  const ::proto::Message& _internal_notemessage() const;
  ::proto::Message* _internal_mutable_notemessage();
  public:
  void unsafe_arena_set_allocated_notemessage(
      ::proto::Message* notemessage);
  ::proto::Message* unsafe_arena_release_notemessage();

  // optional .proto.Money amount = 6;
  bool has_amount() const;
  private:
  bool _internal_has_amount() const;
  public:
  void clear_amount();
  const ::proto::Money& amount() const;
  PROTOBUF_NODISCARD ::proto::Money* release_amount();
  ::proto::Money* mutable_amount();
  void set_allocated_amount(::proto::Money* amount);
  private:
  const ::proto::Money& _internal_amount() const;
  ::proto::Money* _internal_mutable_amount();
  public:
  void unsafe_arena_set_allocated_amount(
      ::proto::Money* amount);
  ::proto::Money* unsafe_arena_release_amount();

  // optional .proto.PaymentBackground background = 7;
  bool has_background() const;
  private:
  bool _internal_has_background() const;
  public:
  void clear_background();
  const ::proto::PaymentBackground& background() const;
  PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background();
  ::proto::PaymentBackground* mutable_background();
  void set_allocated_background(::proto::PaymentBackground* background);
  private:
  const ::proto::PaymentBackground& _internal_background() const;
  ::proto::PaymentBackground* _internal_mutable_background();
  public:
  void unsafe_arena_set_allocated_background(
      ::proto::PaymentBackground* background);
  ::proto::PaymentBackground* unsafe_arena_release_background();

  // optional uint64 amount1000 = 2;
  bool has_amount1000() const;
  private:
  bool _internal_has_amount1000() const;
  public:
  void clear_amount1000();
  uint64_t amount1000() const;
  void set_amount1000(uint64_t value);
  private:
  uint64_t _internal_amount1000() const;
  void _internal_set_amount1000(uint64_t value);
  public:

  // optional int64 expiryTimestamp = 5;
  bool has_expirytimestamp() const;
  private:
  bool _internal_has_expirytimestamp() const;
  public:
  void clear_expirytimestamp();
  int64_t expirytimestamp() const;
  void set_expirytimestamp(int64_t value);
  private:
  int64_t _internal_expirytimestamp() const;
  void _internal_set_expirytimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.RequestPaymentMessage)
 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 currencycodeiso4217_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr requestfrom_;
    ::proto::Message* notemessage_;
    ::proto::Money* amount_;
    ::proto::PaymentBackground* background_;
    uint64_t amount1000_;
    int64_t expirytimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_RequestPhoneNumberMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.RequestPhoneNumberMessage) */ {
 public:
  inline Message_RequestPhoneNumberMessage() : Message_RequestPhoneNumberMessage(nullptr) {}
  ~Message_RequestPhoneNumberMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_RequestPhoneNumberMessage(const Message_RequestPhoneNumberMessage& from);
  Message_RequestPhoneNumberMessage(Message_RequestPhoneNumberMessage&& from) noexcept
    : Message_RequestPhoneNumberMessage() {
    *this = ::std::move(from);
  }

  inline Message_RequestPhoneNumberMessage& operator=(const Message_RequestPhoneNumberMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_RequestPhoneNumberMessage& operator=(Message_RequestPhoneNumberMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_RequestPhoneNumberMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_RequestPhoneNumberMessage* internal_default_instance() {
    return reinterpret_cast<const Message_RequestPhoneNumberMessage*>(
               &_Message_RequestPhoneNumberMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    127;

  friend void swap(Message_RequestPhoneNumberMessage& a, Message_RequestPhoneNumberMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_RequestPhoneNumberMessage* 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(Message_RequestPhoneNumberMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_RequestPhoneNumberMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_RequestPhoneNumberMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_RequestPhoneNumberMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_RequestPhoneNumberMessage& from) {
    Message_RequestPhoneNumberMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_RequestPhoneNumberMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.RequestPhoneNumberMessage";
  }
  protected:
  explicit Message_RequestPhoneNumberMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kContextInfoFieldNumber = 1,
  };
  // optional .proto.ContextInfo contextInfo = 1;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // @@protoc_insertion_point(class_scope:proto.Message.RequestPhoneNumberMessage)
 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_;
    ::proto::ContextInfo* contextinfo_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_SendPaymentMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SendPaymentMessage) */ {
 public:
  inline Message_SendPaymentMessage() : Message_SendPaymentMessage(nullptr) {}
  ~Message_SendPaymentMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_SendPaymentMessage(const Message_SendPaymentMessage& from);
  Message_SendPaymentMessage(Message_SendPaymentMessage&& from) noexcept
    : Message_SendPaymentMessage() {
    *this = ::std::move(from);
  }

  inline Message_SendPaymentMessage& operator=(const Message_SendPaymentMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_SendPaymentMessage& operator=(Message_SendPaymentMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_SendPaymentMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_SendPaymentMessage* internal_default_instance() {
    return reinterpret_cast<const Message_SendPaymentMessage*>(
               &_Message_SendPaymentMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    128;

  friend void swap(Message_SendPaymentMessage& a, Message_SendPaymentMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_SendPaymentMessage* 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(Message_SendPaymentMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_SendPaymentMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_SendPaymentMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_SendPaymentMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_SendPaymentMessage& from) {
    Message_SendPaymentMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_SendPaymentMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.SendPaymentMessage";
  }
  protected:
  explicit Message_SendPaymentMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNoteMessageFieldNumber = 2,
    kRequestMessageKeyFieldNumber = 3,
    kBackgroundFieldNumber = 4,
  };
  // optional .proto.Message noteMessage = 2;
  bool has_notemessage() const;
  private:
  bool _internal_has_notemessage() const;
  public:
  void clear_notemessage();
  const ::proto::Message& notemessage() const;
  PROTOBUF_NODISCARD ::proto::Message* release_notemessage();
  ::proto::Message* mutable_notemessage();
  void set_allocated_notemessage(::proto::Message* notemessage);
  private:
  const ::proto::Message& _internal_notemessage() const;
  ::proto::Message* _internal_mutable_notemessage();
  public:
  void unsafe_arena_set_allocated_notemessage(
      ::proto::Message* notemessage);
  ::proto::Message* unsafe_arena_release_notemessage();

  // optional .proto.MessageKey requestMessageKey = 3;
  bool has_requestmessagekey() const;
  private:
  bool _internal_has_requestmessagekey() const;
  public:
  void clear_requestmessagekey();
  const ::proto::MessageKey& requestmessagekey() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey();
  ::proto::MessageKey* mutable_requestmessagekey();
  void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey);
  private:
  const ::proto::MessageKey& _internal_requestmessagekey() const;
  ::proto::MessageKey* _internal_mutable_requestmessagekey();
  public:
  void unsafe_arena_set_allocated_requestmessagekey(
      ::proto::MessageKey* requestmessagekey);
  ::proto::MessageKey* unsafe_arena_release_requestmessagekey();

  // optional .proto.PaymentBackground background = 4;
  bool has_background() const;
  private:
  bool _internal_has_background() const;
  public:
  void clear_background();
  const ::proto::PaymentBackground& background() const;
  PROTOBUF_NODISCARD ::proto::PaymentBackground* release_background();
  ::proto::PaymentBackground* mutable_background();
  void set_allocated_background(::proto::PaymentBackground* background);
  private:
  const ::proto::PaymentBackground& _internal_background() const;
  ::proto::PaymentBackground* _internal_mutable_background();
  public:
  void unsafe_arena_set_allocated_background(
      ::proto::PaymentBackground* background);
  ::proto::PaymentBackground* unsafe_arena_release_background();

  // @@protoc_insertion_point(class_scope:proto.Message.SendPaymentMessage)
 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_;
    ::proto::Message* notemessage_;
    ::proto::MessageKey* requestmessagekey_;
    ::proto::PaymentBackground* background_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_SenderKeyDistributionMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.SenderKeyDistributionMessage) */ {
 public:
  inline Message_SenderKeyDistributionMessage() : Message_SenderKeyDistributionMessage(nullptr) {}
  ~Message_SenderKeyDistributionMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_SenderKeyDistributionMessage(const Message_SenderKeyDistributionMessage& from);
  Message_SenderKeyDistributionMessage(Message_SenderKeyDistributionMessage&& from) noexcept
    : Message_SenderKeyDistributionMessage() {
    *this = ::std::move(from);
  }

  inline Message_SenderKeyDistributionMessage& operator=(const Message_SenderKeyDistributionMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_SenderKeyDistributionMessage& operator=(Message_SenderKeyDistributionMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_SenderKeyDistributionMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_SenderKeyDistributionMessage* internal_default_instance() {
    return reinterpret_cast<const Message_SenderKeyDistributionMessage*>(
               &_Message_SenderKeyDistributionMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    129;

  friend void swap(Message_SenderKeyDistributionMessage& a, Message_SenderKeyDistributionMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_SenderKeyDistributionMessage* 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(Message_SenderKeyDistributionMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_SenderKeyDistributionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_SenderKeyDistributionMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_SenderKeyDistributionMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_SenderKeyDistributionMessage& from) {
    Message_SenderKeyDistributionMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_SenderKeyDistributionMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.SenderKeyDistributionMessage";
  }
  protected:
  explicit Message_SenderKeyDistributionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kGroupIdFieldNumber = 1,
    kAxolotlSenderKeyDistributionMessageFieldNumber = 2,
  };
  // optional string groupId = 1;
  bool has_groupid() const;
  private:
  bool _internal_has_groupid() const;
  public:
  void clear_groupid();
  const std::string& groupid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupid();
  PROTOBUF_NODISCARD std::string* release_groupid();
  void set_allocated_groupid(std::string* groupid);
  private:
  const std::string& _internal_groupid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupid(const std::string& value);
  std::string* _internal_mutable_groupid();
  public:

  // optional bytes axolotlSenderKeyDistributionMessage = 2;
  bool has_axolotlsenderkeydistributionmessage() const;
  private:
  bool _internal_has_axolotlsenderkeydistributionmessage() const;
  public:
  void clear_axolotlsenderkeydistributionmessage();
  const std::string& axolotlsenderkeydistributionmessage() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args);
  std::string* mutable_axolotlsenderkeydistributionmessage();
  PROTOBUF_NODISCARD std::string* release_axolotlsenderkeydistributionmessage();
  void set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage);
  private:
  const std::string& _internal_axolotlsenderkeydistributionmessage() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_axolotlsenderkeydistributionmessage(const std::string& value);
  std::string* _internal_mutable_axolotlsenderkeydistributionmessage();
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.SenderKeyDistributionMessage)
 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 groupid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr axolotlsenderkeydistributionmessage_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_StickerMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerMessage) */ {
 public:
  inline Message_StickerMessage() : Message_StickerMessage(nullptr) {}
  ~Message_StickerMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_StickerMessage(const Message_StickerMessage& from);
  Message_StickerMessage(Message_StickerMessage&& from) noexcept
    : Message_StickerMessage() {
    *this = ::std::move(from);
  }

  inline Message_StickerMessage& operator=(const Message_StickerMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_StickerMessage& operator=(Message_StickerMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_StickerMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_StickerMessage* internal_default_instance() {
    return reinterpret_cast<const Message_StickerMessage*>(
               &_Message_StickerMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    130;

  friend void swap(Message_StickerMessage& a, Message_StickerMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_StickerMessage* 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(Message_StickerMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_StickerMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_StickerMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_StickerMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_StickerMessage& from) {
    Message_StickerMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_StickerMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.StickerMessage";
  }
  protected:
  explicit Message_StickerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUrlFieldNumber = 1,
    kFileSha256FieldNumber = 2,
    kFileEncSha256FieldNumber = 3,
    kMediaKeyFieldNumber = 4,
    kMimetypeFieldNumber = 5,
    kDirectPathFieldNumber = 8,
    kFirstFrameSidecarFieldNumber = 12,
    kPngThumbnailFieldNumber = 16,
    kContextInfoFieldNumber = 17,
    kHeightFieldNumber = 6,
    kWidthFieldNumber = 7,
    kFileLengthFieldNumber = 9,
    kMediaKeyTimestampFieldNumber = 10,
    kFirstFrameLengthFieldNumber = 11,
    kIsAnimatedFieldNumber = 13,
  };
  // optional 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 bytes fileSha256 = 2;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes fileEncSha256 = 3;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional bytes mediaKey = 4;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string mimetype = 5;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional string directPath = 8;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional bytes firstFrameSidecar = 12;
  bool has_firstframesidecar() const;
  private:
  bool _internal_has_firstframesidecar() const;
  public:
  void clear_firstframesidecar();
  const std::string& firstframesidecar() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_firstframesidecar(ArgT0&& arg0, ArgT... args);
  std::string* mutable_firstframesidecar();
  PROTOBUF_NODISCARD std::string* release_firstframesidecar();
  void set_allocated_firstframesidecar(std::string* firstframesidecar);
  private:
  const std::string& _internal_firstframesidecar() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstframesidecar(const std::string& value);
  std::string* _internal_mutable_firstframesidecar();
  public:

  // optional bytes pngThumbnail = 16;
  bool has_pngthumbnail() const;
  private:
  bool _internal_has_pngthumbnail() const;
  public:
  void clear_pngthumbnail();
  const std::string& pngthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pngthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pngthumbnail();
  PROTOBUF_NODISCARD std::string* release_pngthumbnail();
  void set_allocated_pngthumbnail(std::string* pngthumbnail);
  private:
  const std::string& _internal_pngthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pngthumbnail(const std::string& value);
  std::string* _internal_mutable_pngthumbnail();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint32 height = 6;
  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:

  // optional uint32 width = 7;
  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 uint64 fileLength = 9;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional int64 mediaKeyTimestamp = 10;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // optional uint32 firstFrameLength = 11;
  bool has_firstframelength() const;
  private:
  bool _internal_has_firstframelength() const;
  public:
  void clear_firstframelength();
  uint32_t firstframelength() const;
  void set_firstframelength(uint32_t value);
  private:
  uint32_t _internal_firstframelength() const;
  void _internal_set_firstframelength(uint32_t value);
  public:

  // optional bool isAnimated = 13;
  bool has_isanimated() const;
  private:
  bool _internal_has_isanimated() const;
  public:
  void clear_isanimated();
  bool isanimated() const;
  void set_isanimated(bool value);
  private:
  bool _internal_isanimated() const;
  void _internal_set_isanimated(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.StickerMessage)
 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 filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstframesidecar_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pngthumbnail_;
    ::proto::ContextInfo* contextinfo_;
    uint32_t height_;
    uint32_t width_;
    uint64_t filelength_;
    int64_t mediakeytimestamp_;
    uint32_t firstframelength_;
    bool isanimated_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_StickerSyncRMRMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.StickerSyncRMRMessage) */ {
 public:
  inline Message_StickerSyncRMRMessage() : Message_StickerSyncRMRMessage(nullptr) {}
  ~Message_StickerSyncRMRMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_StickerSyncRMRMessage(const Message_StickerSyncRMRMessage& from);
  Message_StickerSyncRMRMessage(Message_StickerSyncRMRMessage&& from) noexcept
    : Message_StickerSyncRMRMessage() {
    *this = ::std::move(from);
  }

  inline Message_StickerSyncRMRMessage& operator=(const Message_StickerSyncRMRMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_StickerSyncRMRMessage& operator=(Message_StickerSyncRMRMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_StickerSyncRMRMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_StickerSyncRMRMessage* internal_default_instance() {
    return reinterpret_cast<const Message_StickerSyncRMRMessage*>(
               &_Message_StickerSyncRMRMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    131;

  friend void swap(Message_StickerSyncRMRMessage& a, Message_StickerSyncRMRMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_StickerSyncRMRMessage* 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(Message_StickerSyncRMRMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_StickerSyncRMRMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_StickerSyncRMRMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_StickerSyncRMRMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_StickerSyncRMRMessage& from) {
    Message_StickerSyncRMRMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_StickerSyncRMRMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.StickerSyncRMRMessage";
  }
  protected:
  explicit Message_StickerSyncRMRMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFilehashFieldNumber = 1,
    kRmrSourceFieldNumber = 2,
    kRequestTimestampFieldNumber = 3,
  };
  // repeated string filehash = 1;
  int filehash_size() const;
  private:
  int _internal_filehash_size() const;
  public:
  void clear_filehash();
  const std::string& filehash(int index) const;
  std::string* mutable_filehash(int index);
  void set_filehash(int index, const std::string& value);
  void set_filehash(int index, std::string&& value);
  void set_filehash(int index, const char* value);
  void set_filehash(int index, const char* value, size_t size);
  std::string* add_filehash();
  void add_filehash(const std::string& value);
  void add_filehash(std::string&& value);
  void add_filehash(const char* value);
  void add_filehash(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& filehash() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_filehash();
  private:
  const std::string& _internal_filehash(int index) const;
  std::string* _internal_add_filehash();
  public:

  // optional string rmrSource = 2;
  bool has_rmrsource() const;
  private:
  bool _internal_has_rmrsource() const;
  public:
  void clear_rmrsource();
  const std::string& rmrsource() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rmrsource(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rmrsource();
  PROTOBUF_NODISCARD std::string* release_rmrsource();
  void set_allocated_rmrsource(std::string* rmrsource);
  private:
  const std::string& _internal_rmrsource() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rmrsource(const std::string& value);
  std::string* _internal_mutable_rmrsource();
  public:

  // optional int64 requestTimestamp = 3;
  bool has_requesttimestamp() const;
  private:
  bool _internal_has_requesttimestamp() const;
  public:
  void clear_requesttimestamp();
  int64_t requesttimestamp() const;
  void set_requesttimestamp(int64_t value);
  private:
  int64_t _internal_requesttimestamp() const;
  void _internal_set_requesttimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.StickerSyncRMRMessage)
 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> filehash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rmrsource_;
    int64_t requesttimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_TemplateButtonReplyMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateButtonReplyMessage) */ {
 public:
  inline Message_TemplateButtonReplyMessage() : Message_TemplateButtonReplyMessage(nullptr) {}
  ~Message_TemplateButtonReplyMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_TemplateButtonReplyMessage(const Message_TemplateButtonReplyMessage& from);
  Message_TemplateButtonReplyMessage(Message_TemplateButtonReplyMessage&& from) noexcept
    : Message_TemplateButtonReplyMessage() {
    *this = ::std::move(from);
  }

  inline Message_TemplateButtonReplyMessage& operator=(const Message_TemplateButtonReplyMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_TemplateButtonReplyMessage& operator=(Message_TemplateButtonReplyMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_TemplateButtonReplyMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_TemplateButtonReplyMessage* internal_default_instance() {
    return reinterpret_cast<const Message_TemplateButtonReplyMessage*>(
               &_Message_TemplateButtonReplyMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    132;

  friend void swap(Message_TemplateButtonReplyMessage& a, Message_TemplateButtonReplyMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_TemplateButtonReplyMessage* 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(Message_TemplateButtonReplyMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_TemplateButtonReplyMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_TemplateButtonReplyMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_TemplateButtonReplyMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_TemplateButtonReplyMessage& from) {
    Message_TemplateButtonReplyMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_TemplateButtonReplyMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.TemplateButtonReplyMessage";
  }
  protected:
  explicit Message_TemplateButtonReplyMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSelectedIdFieldNumber = 1,
    kSelectedDisplayTextFieldNumber = 2,
    kContextInfoFieldNumber = 3,
    kSelectedIndexFieldNumber = 4,
  };
  // optional string selectedId = 1;
  bool has_selectedid() const;
  private:
  bool _internal_has_selectedid() const;
  public:
  void clear_selectedid();
  const std::string& selectedid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_selectedid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_selectedid();
  PROTOBUF_NODISCARD std::string* release_selectedid();
  void set_allocated_selectedid(std::string* selectedid);
  private:
  const std::string& _internal_selectedid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selectedid(const std::string& value);
  std::string* _internal_mutable_selectedid();
  public:

  // optional string selectedDisplayText = 2;
  bool has_selecteddisplaytext() const;
  private:
  bool _internal_has_selecteddisplaytext() const;
  public:
  void clear_selecteddisplaytext();
  const std::string& selecteddisplaytext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_selecteddisplaytext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_selecteddisplaytext();
  PROTOBUF_NODISCARD std::string* release_selecteddisplaytext();
  void set_allocated_selecteddisplaytext(std::string* selecteddisplaytext);
  private:
  const std::string& _internal_selecteddisplaytext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_selecteddisplaytext(const std::string& value);
  std::string* _internal_mutable_selecteddisplaytext();
  public:

  // optional .proto.ContextInfo contextInfo = 3;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint32 selectedIndex = 4;
  bool has_selectedindex() const;
  private:
  bool _internal_has_selectedindex() const;
  public:
  void clear_selectedindex();
  uint32_t selectedindex() const;
  void set_selectedindex(uint32_t value);
  private:
  uint32_t _internal_selectedindex() const;
  void _internal_set_selectedindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.TemplateButtonReplyMessage)
 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 selectedid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr selecteddisplaytext_;
    ::proto::ContextInfo* contextinfo_;
    uint32_t selectedindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_TemplateMessage_FourRowTemplate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.FourRowTemplate) */ {
 public:
  inline Message_TemplateMessage_FourRowTemplate() : Message_TemplateMessage_FourRowTemplate(nullptr) {}
  ~Message_TemplateMessage_FourRowTemplate() override;
  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_TemplateMessage_FourRowTemplate(const Message_TemplateMessage_FourRowTemplate& from);
  Message_TemplateMessage_FourRowTemplate(Message_TemplateMessage_FourRowTemplate&& from) noexcept
    : Message_TemplateMessage_FourRowTemplate() {
    *this = ::std::move(from);
  }

  inline Message_TemplateMessage_FourRowTemplate& operator=(const Message_TemplateMessage_FourRowTemplate& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_TemplateMessage_FourRowTemplate& operator=(Message_TemplateMessage_FourRowTemplate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_TemplateMessage_FourRowTemplate& default_instance() {
    return *internal_default_instance();
  }
  enum TitleCase {
    kDocumentMessage = 1,
    kHighlyStructuredMessage = 2,
    kImageMessage = 3,
    kVideoMessage = 4,
    kLocationMessage = 5,
    TITLE_NOT_SET = 0,
  };

  static inline const Message_TemplateMessage_FourRowTemplate* internal_default_instance() {
    return reinterpret_cast<const Message_TemplateMessage_FourRowTemplate*>(
               &_Message_TemplateMessage_FourRowTemplate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    133;

  friend void swap(Message_TemplateMessage_FourRowTemplate& a, Message_TemplateMessage_FourRowTemplate& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_TemplateMessage_FourRowTemplate* 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(Message_TemplateMessage_FourRowTemplate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_TemplateMessage_FourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_TemplateMessage_FourRowTemplate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_TemplateMessage_FourRowTemplate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_TemplateMessage_FourRowTemplate& from) {
    Message_TemplateMessage_FourRowTemplate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_TemplateMessage_FourRowTemplate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.TemplateMessage.FourRowTemplate";
  }
  protected:
  explicit Message_TemplateMessage_FourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kButtonsFieldNumber = 8,
    kContentFieldNumber = 6,
    kFooterFieldNumber = 7,
    kDocumentMessageFieldNumber = 1,
    kHighlyStructuredMessageFieldNumber = 2,
    kImageMessageFieldNumber = 3,
    kVideoMessageFieldNumber = 4,
    kLocationMessageFieldNumber = 5,
  };
  // repeated .proto.TemplateButton buttons = 8;
  int buttons_size() const;
  private:
  int _internal_buttons_size() const;
  public:
  void clear_buttons();
  ::proto::TemplateButton* mutable_buttons(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >*
      mutable_buttons();
  private:
  const ::proto::TemplateButton& _internal_buttons(int index) const;
  ::proto::TemplateButton* _internal_add_buttons();
  public:
  const ::proto::TemplateButton& buttons(int index) const;
  ::proto::TemplateButton* add_buttons();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >&
      buttons() const;

  // optional .proto.Message.HighlyStructuredMessage content = 6;
  bool has_content() const;
  private:
  bool _internal_has_content() const;
  public:
  void clear_content();
  const ::proto::Message_HighlyStructuredMessage& content() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_content();
  ::proto::Message_HighlyStructuredMessage* mutable_content();
  void set_allocated_content(::proto::Message_HighlyStructuredMessage* content);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_content() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_content();
  public:
  void unsafe_arena_set_allocated_content(
      ::proto::Message_HighlyStructuredMessage* content);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_content();

  // optional .proto.Message.HighlyStructuredMessage footer = 7;
  bool has_footer() const;
  private:
  bool _internal_has_footer() const;
  public:
  void clear_footer();
  const ::proto::Message_HighlyStructuredMessage& footer() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_footer();
  ::proto::Message_HighlyStructuredMessage* mutable_footer();
  void set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_footer() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_footer();
  public:
  void unsafe_arena_set_allocated_footer(
      ::proto::Message_HighlyStructuredMessage* footer);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_footer();

  // .proto.Message.DocumentMessage documentMessage = 1;
  bool has_documentmessage() const;
  private:
  bool _internal_has_documentmessage() const;
  public:
  void clear_documentmessage();
  const ::proto::Message_DocumentMessage& documentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
  ::proto::Message_DocumentMessage* mutable_documentmessage();
  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
  private:
  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
  public:
  void unsafe_arena_set_allocated_documentmessage(
      ::proto::Message_DocumentMessage* documentmessage);
  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();

  // .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
  bool has_highlystructuredmessage() const;
  private:
  bool _internal_has_highlystructuredmessage() const;
  public:
  void clear_highlystructuredmessage();
  const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage();
  ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage();
  void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage();
  public:
  void unsafe_arena_set_allocated_highlystructuredmessage(
      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage();

  // .proto.Message.ImageMessage imageMessage = 3;
  bool has_imagemessage() const;
  private:
  bool _internal_has_imagemessage() const;
  public:
  void clear_imagemessage();
  const ::proto::Message_ImageMessage& imagemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
  ::proto::Message_ImageMessage* mutable_imagemessage();
  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
  private:
  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
  public:
  void unsafe_arena_set_allocated_imagemessage(
      ::proto::Message_ImageMessage* imagemessage);
  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();

  // .proto.Message.VideoMessage videoMessage = 4;
  bool has_videomessage() const;
  private:
  bool _internal_has_videomessage() const;
  public:
  void clear_videomessage();
  const ::proto::Message_VideoMessage& videomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
  ::proto::Message_VideoMessage* mutable_videomessage();
  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
  private:
  const ::proto::Message_VideoMessage& _internal_videomessage() const;
  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
  public:
  void unsafe_arena_set_allocated_videomessage(
      ::proto::Message_VideoMessage* videomessage);
  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();

  // .proto.Message.LocationMessage locationMessage = 5;
  bool has_locationmessage() const;
  private:
  bool _internal_has_locationmessage() const;
  public:
  void clear_locationmessage();
  const ::proto::Message_LocationMessage& locationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
  ::proto::Message_LocationMessage* mutable_locationmessage();
  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
  private:
  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
  public:
  void unsafe_arena_set_allocated_locationmessage(
      ::proto::Message_LocationMessage* locationmessage);
  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();

  void clear_title();
  TitleCase title_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.FourRowTemplate)
 private:
  class _Internal;
  void set_has_documentmessage();
  void set_has_highlystructuredmessage();
  void set_has_imagemessage();
  void set_has_videomessage();
  void set_has_locationmessage();

  inline bool has_title() const;
  inline void clear_has_title();

  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< ::proto::TemplateButton > buttons_;
    ::proto::Message_HighlyStructuredMessage* content_;
    ::proto::Message_HighlyStructuredMessage* footer_;
    union TitleUnion {
      constexpr TitleUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_DocumentMessage* documentmessage_;
      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_;
      ::proto::Message_ImageMessage* imagemessage_;
      ::proto::Message_VideoMessage* videomessage_;
      ::proto::Message_LocationMessage* locationmessage_;
    } title_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_TemplateMessage_HydratedFourRowTemplate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage.HydratedFourRowTemplate) */ {
 public:
  inline Message_TemplateMessage_HydratedFourRowTemplate() : Message_TemplateMessage_HydratedFourRowTemplate(nullptr) {}
  ~Message_TemplateMessage_HydratedFourRowTemplate() override;
  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_TemplateMessage_HydratedFourRowTemplate(const Message_TemplateMessage_HydratedFourRowTemplate& from);
  Message_TemplateMessage_HydratedFourRowTemplate(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept
    : Message_TemplateMessage_HydratedFourRowTemplate() {
    *this = ::std::move(from);
  }

  inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(const Message_TemplateMessage_HydratedFourRowTemplate& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_TemplateMessage_HydratedFourRowTemplate& operator=(Message_TemplateMessage_HydratedFourRowTemplate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_TemplateMessage_HydratedFourRowTemplate& default_instance() {
    return *internal_default_instance();
  }
  enum TitleCase {
    kDocumentMessage = 1,
    kHydratedTitleText = 2,
    kImageMessage = 3,
    kVideoMessage = 4,
    kLocationMessage = 5,
    TITLE_NOT_SET = 0,
  };

  static inline const Message_TemplateMessage_HydratedFourRowTemplate* internal_default_instance() {
    return reinterpret_cast<const Message_TemplateMessage_HydratedFourRowTemplate*>(
               &_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    134;

  friend void swap(Message_TemplateMessage_HydratedFourRowTemplate& a, Message_TemplateMessage_HydratedFourRowTemplate& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_TemplateMessage_HydratedFourRowTemplate* 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(Message_TemplateMessage_HydratedFourRowTemplate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_TemplateMessage_HydratedFourRowTemplate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_TemplateMessage_HydratedFourRowTemplate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_TemplateMessage_HydratedFourRowTemplate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_TemplateMessage_HydratedFourRowTemplate& from) {
    Message_TemplateMessage_HydratedFourRowTemplate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_TemplateMessage_HydratedFourRowTemplate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.TemplateMessage.HydratedFourRowTemplate";
  }
  protected:
  explicit Message_TemplateMessage_HydratedFourRowTemplate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kHydratedButtonsFieldNumber = 8,
    kHydratedContentTextFieldNumber = 6,
    kHydratedFooterTextFieldNumber = 7,
    kTemplateIdFieldNumber = 9,
    kDocumentMessageFieldNumber = 1,
    kHydratedTitleTextFieldNumber = 2,
    kImageMessageFieldNumber = 3,
    kVideoMessageFieldNumber = 4,
    kLocationMessageFieldNumber = 5,
  };
  // repeated .proto.HydratedTemplateButton hydratedButtons = 8;
  int hydratedbuttons_size() const;
  private:
  int _internal_hydratedbuttons_size() const;
  public:
  void clear_hydratedbuttons();
  ::proto::HydratedTemplateButton* mutable_hydratedbuttons(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >*
      mutable_hydratedbuttons();
  private:
  const ::proto::HydratedTemplateButton& _internal_hydratedbuttons(int index) const;
  ::proto::HydratedTemplateButton* _internal_add_hydratedbuttons();
  public:
  const ::proto::HydratedTemplateButton& hydratedbuttons(int index) const;
  ::proto::HydratedTemplateButton* add_hydratedbuttons();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >&
      hydratedbuttons() const;

  // optional string hydratedContentText = 6;
  bool has_hydratedcontenttext() const;
  private:
  bool _internal_has_hydratedcontenttext() const;
  public:
  void clear_hydratedcontenttext();
  const std::string& hydratedcontenttext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hydratedcontenttext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hydratedcontenttext();
  PROTOBUF_NODISCARD std::string* release_hydratedcontenttext();
  void set_allocated_hydratedcontenttext(std::string* hydratedcontenttext);
  private:
  const std::string& _internal_hydratedcontenttext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedcontenttext(const std::string& value);
  std::string* _internal_mutable_hydratedcontenttext();
  public:

  // optional string hydratedFooterText = 7;
  bool has_hydratedfootertext() const;
  private:
  bool _internal_has_hydratedfootertext() const;
  public:
  void clear_hydratedfootertext();
  const std::string& hydratedfootertext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hydratedfootertext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hydratedfootertext();
  PROTOBUF_NODISCARD std::string* release_hydratedfootertext();
  void set_allocated_hydratedfootertext(std::string* hydratedfootertext);
  private:
  const std::string& _internal_hydratedfootertext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedfootertext(const std::string& value);
  std::string* _internal_mutable_hydratedfootertext();
  public:

  // optional string templateId = 9;
  bool has_templateid() const;
  private:
  bool _internal_has_templateid() const;
  public:
  void clear_templateid();
  const std::string& templateid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_templateid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_templateid();
  PROTOBUF_NODISCARD std::string* release_templateid();
  void set_allocated_templateid(std::string* templateid);
  private:
  const std::string& _internal_templateid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_templateid(const std::string& value);
  std::string* _internal_mutable_templateid();
  public:

  // .proto.Message.DocumentMessage documentMessage = 1;
  bool has_documentmessage() const;
  private:
  bool _internal_has_documentmessage() const;
  public:
  void clear_documentmessage();
  const ::proto::Message_DocumentMessage& documentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
  ::proto::Message_DocumentMessage* mutable_documentmessage();
  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
  private:
  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
  public:
  void unsafe_arena_set_allocated_documentmessage(
      ::proto::Message_DocumentMessage* documentmessage);
  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();

  // string hydratedTitleText = 2;
  bool has_hydratedtitletext() const;
  private:
  bool _internal_has_hydratedtitletext() const;
  public:
  void clear_hydratedtitletext();
  const std::string& hydratedtitletext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hydratedtitletext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hydratedtitletext();
  PROTOBUF_NODISCARD std::string* release_hydratedtitletext();
  void set_allocated_hydratedtitletext(std::string* hydratedtitletext);
  private:
  const std::string& _internal_hydratedtitletext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hydratedtitletext(const std::string& value);
  std::string* _internal_mutable_hydratedtitletext();
  public:

  // .proto.Message.ImageMessage imageMessage = 3;
  bool has_imagemessage() const;
  private:
  bool _internal_has_imagemessage() const;
  public:
  void clear_imagemessage();
  const ::proto::Message_ImageMessage& imagemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
  ::proto::Message_ImageMessage* mutable_imagemessage();
  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
  private:
  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
  public:
  void unsafe_arena_set_allocated_imagemessage(
      ::proto::Message_ImageMessage* imagemessage);
  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();

  // .proto.Message.VideoMessage videoMessage = 4;
  bool has_videomessage() const;
  private:
  bool _internal_has_videomessage() const;
  public:
  void clear_videomessage();
  const ::proto::Message_VideoMessage& videomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
  ::proto::Message_VideoMessage* mutable_videomessage();
  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
  private:
  const ::proto::Message_VideoMessage& _internal_videomessage() const;
  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
  public:
  void unsafe_arena_set_allocated_videomessage(
      ::proto::Message_VideoMessage* videomessage);
  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();

  // .proto.Message.LocationMessage locationMessage = 5;
  bool has_locationmessage() const;
  private:
  bool _internal_has_locationmessage() const;
  public:
  void clear_locationmessage();
  const ::proto::Message_LocationMessage& locationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
  ::proto::Message_LocationMessage* mutable_locationmessage();
  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
  private:
  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
  public:
  void unsafe_arena_set_allocated_locationmessage(
      ::proto::Message_LocationMessage* locationmessage);
  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();

  void clear_title();
  TitleCase title_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage.HydratedFourRowTemplate)
 private:
  class _Internal;
  void set_has_documentmessage();
  void set_has_hydratedtitletext();
  void set_has_imagemessage();
  void set_has_videomessage();
  void set_has_locationmessage();

  inline bool has_title() const;
  inline void clear_has_title();

  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< ::proto::HydratedTemplateButton > hydratedbuttons_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedcontenttext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedfootertext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr templateid_;
    union TitleUnion {
      constexpr TitleUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_DocumentMessage* documentmessage_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hydratedtitletext_;
      ::proto::Message_ImageMessage* imagemessage_;
      ::proto::Message_VideoMessage* videomessage_;
      ::proto::Message_LocationMessage* locationmessage_;
    } title_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_TemplateMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.TemplateMessage) */ {
 public:
  inline Message_TemplateMessage() : Message_TemplateMessage(nullptr) {}
  ~Message_TemplateMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_TemplateMessage(const Message_TemplateMessage& from);
  Message_TemplateMessage(Message_TemplateMessage&& from) noexcept
    : Message_TemplateMessage() {
    *this = ::std::move(from);
  }

  inline Message_TemplateMessage& operator=(const Message_TemplateMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_TemplateMessage& operator=(Message_TemplateMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_TemplateMessage& default_instance() {
    return *internal_default_instance();
  }
  enum FormatCase {
    kFourRowTemplate = 1,
    kHydratedFourRowTemplate = 2,
    FORMAT_NOT_SET = 0,
  };

  static inline const Message_TemplateMessage* internal_default_instance() {
    return reinterpret_cast<const Message_TemplateMessage*>(
               &_Message_TemplateMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    135;

  friend void swap(Message_TemplateMessage& a, Message_TemplateMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_TemplateMessage* 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(Message_TemplateMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_TemplateMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_TemplateMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_TemplateMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_TemplateMessage& from) {
    Message_TemplateMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_TemplateMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.TemplateMessage";
  }
  protected:
  explicit Message_TemplateMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_TemplateMessage_FourRowTemplate FourRowTemplate;
  typedef Message_TemplateMessage_HydratedFourRowTemplate HydratedFourRowTemplate;

  // accessors -------------------------------------------------------

  enum : int {
    kContextInfoFieldNumber = 3,
    kHydratedTemplateFieldNumber = 4,
    kFourRowTemplateFieldNumber = 1,
    kHydratedFourRowTemplateFieldNumber = 2,
  };
  // optional .proto.ContextInfo contextInfo = 3;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
  bool has_hydratedtemplate() const;
  private:
  bool _internal_has_hydratedtemplate() const;
  public:
  void clear_hydratedtemplate();
  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedtemplate() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedtemplate();
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedtemplate();
  void set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate);
  private:
  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedtemplate() const;
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedtemplate();
  public:
  void unsafe_arena_set_allocated_hydratedtemplate(
      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate);
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedtemplate();

  // .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
  bool has_fourrowtemplate() const;
  private:
  bool _internal_has_fourrowtemplate() const;
  public:
  void clear_fourrowtemplate();
  const ::proto::Message_TemplateMessage_FourRowTemplate& fourrowtemplate() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_FourRowTemplate* release_fourrowtemplate();
  ::proto::Message_TemplateMessage_FourRowTemplate* mutable_fourrowtemplate();
  void set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate);
  private:
  const ::proto::Message_TemplateMessage_FourRowTemplate& _internal_fourrowtemplate() const;
  ::proto::Message_TemplateMessage_FourRowTemplate* _internal_mutable_fourrowtemplate();
  public:
  void unsafe_arena_set_allocated_fourrowtemplate(
      ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate);
  ::proto::Message_TemplateMessage_FourRowTemplate* unsafe_arena_release_fourrowtemplate();

  // .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
  bool has_hydratedfourrowtemplate() const;
  private:
  bool _internal_has_hydratedfourrowtemplate() const;
  public:
  void clear_hydratedfourrowtemplate();
  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& hydratedfourrowtemplate() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage_HydratedFourRowTemplate* release_hydratedfourrowtemplate();
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* mutable_hydratedfourrowtemplate();
  void set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate);
  private:
  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& _internal_hydratedfourrowtemplate() const;
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _internal_mutable_hydratedfourrowtemplate();
  public:
  void unsafe_arena_set_allocated_hydratedfourrowtemplate(
      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate);
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* unsafe_arena_release_hydratedfourrowtemplate();

  void clear_format();
  FormatCase format_case() const;
  // @@protoc_insertion_point(class_scope:proto.Message.TemplateMessage)
 private:
  class _Internal;
  void set_has_fourrowtemplate();
  void set_has_hydratedfourrowtemplate();

  inline bool has_format() const;
  inline void clear_has_format();

  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_;
    ::proto::ContextInfo* contextinfo_;
    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate_;
    union FormatUnion {
      constexpr FormatUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate_;
      ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate_;
    } format_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message_VideoMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message.VideoMessage) */ {
 public:
  inline Message_VideoMessage() : Message_VideoMessage(nullptr) {}
  ~Message_VideoMessage() override;
  explicit PROTOBUF_CONSTEXPR Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message_VideoMessage(const Message_VideoMessage& from);
  Message_VideoMessage(Message_VideoMessage&& from) noexcept
    : Message_VideoMessage() {
    *this = ::std::move(from);
  }

  inline Message_VideoMessage& operator=(const Message_VideoMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message_VideoMessage& operator=(Message_VideoMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message_VideoMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message_VideoMessage* internal_default_instance() {
    return reinterpret_cast<const Message_VideoMessage*>(
               &_Message_VideoMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    136;

  friend void swap(Message_VideoMessage& a, Message_VideoMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(Message_VideoMessage* 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(Message_VideoMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message_VideoMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message_VideoMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message_VideoMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message_VideoMessage& from) {
    Message_VideoMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message_VideoMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message.VideoMessage";
  }
  protected:
  explicit Message_VideoMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_VideoMessage_Attribution Attribution;
  static constexpr Attribution NONE =
    Message_VideoMessage_Attribution_NONE;
  static constexpr Attribution GIPHY =
    Message_VideoMessage_Attribution_GIPHY;
  static constexpr Attribution TENOR =
    Message_VideoMessage_Attribution_TENOR;
  static inline bool Attribution_IsValid(int value) {
    return Message_VideoMessage_Attribution_IsValid(value);
  }
  static constexpr Attribution Attribution_MIN =
    Message_VideoMessage_Attribution_Attribution_MIN;
  static constexpr Attribution Attribution_MAX =
    Message_VideoMessage_Attribution_Attribution_MAX;
  static constexpr int Attribution_ARRAYSIZE =
    Message_VideoMessage_Attribution_Attribution_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Attribution_descriptor() {
    return Message_VideoMessage_Attribution_descriptor();
  }
  template<typename T>
  static inline const std::string& Attribution_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Attribution>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Attribution_Name.");
    return Message_VideoMessage_Attribution_Name(enum_t_value);
  }
  static inline bool Attribution_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Attribution* value) {
    return Message_VideoMessage_Attribution_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kInteractiveAnnotationsFieldNumber = 12,
    kUrlFieldNumber = 1,
    kMimetypeFieldNumber = 2,
    kFileSha256FieldNumber = 3,
    kMediaKeyFieldNumber = 6,
    kCaptionFieldNumber = 7,
    kFileEncSha256FieldNumber = 11,
    kDirectPathFieldNumber = 13,
    kJpegThumbnailFieldNumber = 16,
    kStreamingSidecarFieldNumber = 18,
    kThumbnailDirectPathFieldNumber = 21,
    kThumbnailSha256FieldNumber = 22,
    kThumbnailEncSha256FieldNumber = 23,
    kStaticUrlFieldNumber = 24,
    kContextInfoFieldNumber = 17,
    kFileLengthFieldNumber = 4,
    kSecondsFieldNumber = 5,
    kHeightFieldNumber = 9,
    kWidthFieldNumber = 10,
    kGifPlaybackFieldNumber = 8,
    kViewOnceFieldNumber = 20,
    kMediaKeyTimestampFieldNumber = 14,
    kGifAttributionFieldNumber = 19,
  };
  // repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
  int interactiveannotations_size() const;
  private:
  int _internal_interactiveannotations_size() const;
  public:
  void clear_interactiveannotations();
  ::proto::InteractiveAnnotation* mutable_interactiveannotations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
      mutable_interactiveannotations();
  private:
  const ::proto::InteractiveAnnotation& _internal_interactiveannotations(int index) const;
  ::proto::InteractiveAnnotation* _internal_add_interactiveannotations();
  public:
  const ::proto::InteractiveAnnotation& interactiveannotations(int index) const;
  ::proto::InteractiveAnnotation* add_interactiveannotations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
      interactiveannotations() const;

  // optional 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 mimetype = 2;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional bytes fileSha256 = 3;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes mediaKey = 6;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string caption = 7;
  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 bytes fileEncSha256 = 11;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 13;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional bytes jpegThumbnail = 16;
  bool has_jpegthumbnail() const;
  private:
  bool _internal_has_jpegthumbnail() const;
  public:
  void clear_jpegthumbnail();
  const std::string& jpegthumbnail() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_jpegthumbnail(ArgT0&& arg0, ArgT... args);
  std::string* mutable_jpegthumbnail();
  PROTOBUF_NODISCARD std::string* release_jpegthumbnail();
  void set_allocated_jpegthumbnail(std::string* jpegthumbnail);
  private:
  const std::string& _internal_jpegthumbnail() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_jpegthumbnail(const std::string& value);
  std::string* _internal_mutable_jpegthumbnail();
  public:

  // optional bytes streamingSidecar = 18;
  bool has_streamingsidecar() const;
  private:
  bool _internal_has_streamingsidecar() const;
  public:
  void clear_streamingsidecar();
  const std::string& streamingsidecar() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_streamingsidecar(ArgT0&& arg0, ArgT... args);
  std::string* mutable_streamingsidecar();
  PROTOBUF_NODISCARD std::string* release_streamingsidecar();
  void set_allocated_streamingsidecar(std::string* streamingsidecar);
  private:
  const std::string& _internal_streamingsidecar() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_streamingsidecar(const std::string& value);
  std::string* _internal_mutable_streamingsidecar();
  public:

  // optional string thumbnailDirectPath = 21;
  bool has_thumbnaildirectpath() const;
  private:
  bool _internal_has_thumbnaildirectpath() const;
  public:
  void clear_thumbnaildirectpath();
  const std::string& thumbnaildirectpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnaildirectpath();
  PROTOBUF_NODISCARD std::string* release_thumbnaildirectpath();
  void set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath);
  private:
  const std::string& _internal_thumbnaildirectpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnaildirectpath(const std::string& value);
  std::string* _internal_mutable_thumbnaildirectpath();
  public:

  // optional bytes thumbnailSha256 = 22;
  bool has_thumbnailsha256() const;
  private:
  bool _internal_has_thumbnailsha256() const;
  public:
  void clear_thumbnailsha256();
  const std::string& thumbnailsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailsha256();
  void set_allocated_thumbnailsha256(std::string* thumbnailsha256);
  private:
  const std::string& _internal_thumbnailsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailsha256();
  public:

  // optional bytes thumbnailEncSha256 = 23;
  bool has_thumbnailencsha256() const;
  private:
  bool _internal_has_thumbnailencsha256() const;
  public:
  void clear_thumbnailencsha256();
  const std::string& thumbnailencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_thumbnailencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_thumbnailencsha256();
  PROTOBUF_NODISCARD std::string* release_thumbnailencsha256();
  void set_allocated_thumbnailencsha256(std::string* thumbnailencsha256);
  private:
  const std::string& _internal_thumbnailencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_thumbnailencsha256(const std::string& value);
  std::string* _internal_mutable_thumbnailencsha256();
  public:

  // optional string staticUrl = 24;
  bool has_staticurl() const;
  private:
  bool _internal_has_staticurl() const;
  public:
  void clear_staticurl();
  const std::string& staticurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_staticurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_staticurl();
  PROTOBUF_NODISCARD std::string* release_staticurl();
  void set_allocated_staticurl(std::string* staticurl);
  private:
  const std::string& _internal_staticurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_staticurl(const std::string& value);
  std::string* _internal_mutable_staticurl();
  public:

  // optional .proto.ContextInfo contextInfo = 17;
  bool has_contextinfo() const;
  private:
  bool _internal_has_contextinfo() const;
  public:
  void clear_contextinfo();
  const ::proto::ContextInfo& contextinfo() const;
  PROTOBUF_NODISCARD ::proto::ContextInfo* release_contextinfo();
  ::proto::ContextInfo* mutable_contextinfo();
  void set_allocated_contextinfo(::proto::ContextInfo* contextinfo);
  private:
  const ::proto::ContextInfo& _internal_contextinfo() const;
  ::proto::ContextInfo* _internal_mutable_contextinfo();
  public:
  void unsafe_arena_set_allocated_contextinfo(
      ::proto::ContextInfo* contextinfo);
  ::proto::ContextInfo* unsafe_arena_release_contextinfo();

  // optional uint64 fileLength = 4;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional uint32 seconds = 5;
  bool has_seconds() const;
  private:
  bool _internal_has_seconds() const;
  public:
  void clear_seconds();
  uint32_t seconds() const;
  void set_seconds(uint32_t value);
  private:
  uint32_t _internal_seconds() const;
  void _internal_set_seconds(uint32_t value);
  public:

  // optional uint32 height = 9;
  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:

  // optional uint32 width = 10;
  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 bool gifPlayback = 8;
  bool has_gifplayback() const;
  private:
  bool _internal_has_gifplayback() const;
  public:
  void clear_gifplayback();
  bool gifplayback() const;
  void set_gifplayback(bool value);
  private:
  bool _internal_gifplayback() const;
  void _internal_set_gifplayback(bool value);
  public:

  // optional bool viewOnce = 20;
  bool has_viewonce() const;
  private:
  bool _internal_has_viewonce() const;
  public:
  void clear_viewonce();
  bool viewonce() const;
  void set_viewonce(bool value);
  private:
  bool _internal_viewonce() const;
  void _internal_set_viewonce(bool value);
  public:

  // optional int64 mediaKeyTimestamp = 14;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
  bool has_gifattribution() const;
  private:
  bool _internal_has_gifattribution() const;
  public:
  void clear_gifattribution();
  ::proto::Message_VideoMessage_Attribution gifattribution() const;
  void set_gifattribution(::proto::Message_VideoMessage_Attribution value);
  private:
  ::proto::Message_VideoMessage_Attribution _internal_gifattribution() const;
  void _internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Message.VideoMessage)
 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< ::proto::InteractiveAnnotation > interactiveannotations_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr jpegthumbnail_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr streamingsidecar_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnaildirectpath_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thumbnailencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr staticurl_;
    ::proto::ContextInfo* contextinfo_;
    uint64_t filelength_;
    uint32_t seconds_;
    uint32_t height_;
    uint32_t width_;
    bool gifplayback_;
    bool viewonce_;
    int64_t mediakeytimestamp_;
    int gifattribution_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Message final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Message) */ {
 public:
  inline Message() : Message(nullptr) {}
  ~Message() override;
  explicit PROTOBUF_CONSTEXPR Message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Message(const Message& from);
  Message(Message&& from) noexcept
    : Message() {
    *this = ::std::move(from);
  }

  inline Message& operator=(const Message& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message& operator=(Message&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Message& default_instance() {
    return *internal_default_instance();
  }
  static inline const Message* internal_default_instance() {
    return reinterpret_cast<const Message*>(
               &_Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    137;

  friend void swap(Message& a, Message& b) {
    a.Swap(&b);
  }
  inline void Swap(Message* 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(Message* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Message>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Message& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Message& from) {
    Message::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Message";
  }
  protected:
  explicit Message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef Message_AppStateFatalExceptionNotification AppStateFatalExceptionNotification;
  typedef Message_AppStateSyncKeyData AppStateSyncKeyData;
  typedef Message_AppStateSyncKeyFingerprint AppStateSyncKeyFingerprint;
  typedef Message_AppStateSyncKeyId AppStateSyncKeyId;
  typedef Message_AppStateSyncKeyRequest AppStateSyncKeyRequest;
  typedef Message_AppStateSyncKeyShare AppStateSyncKeyShare;
  typedef Message_AppStateSyncKey AppStateSyncKey;
  typedef Message_AudioMessage AudioMessage;
  typedef Message_ButtonsMessage ButtonsMessage;
  typedef Message_ButtonsResponseMessage ButtonsResponseMessage;
  typedef Message_Call Call;
  typedef Message_CancelPaymentRequestMessage CancelPaymentRequestMessage;
  typedef Message_Chat Chat;
  typedef Message_ContactMessage ContactMessage;
  typedef Message_ContactsArrayMessage ContactsArrayMessage;
  typedef Message_DeclinePaymentRequestMessage DeclinePaymentRequestMessage;
  typedef Message_DeviceSentMessage DeviceSentMessage;
  typedef Message_DocumentMessage DocumentMessage;
  typedef Message_ExtendedTextMessage ExtendedTextMessage;
  typedef Message_FutureProofMessage FutureProofMessage;
  typedef Message_GroupInviteMessage GroupInviteMessage;
  typedef Message_HighlyStructuredMessage HighlyStructuredMessage;
  typedef Message_HistorySyncNotification HistorySyncNotification;
  typedef Message_ImageMessage ImageMessage;
  typedef Message_InitialSecurityNotificationSettingSync InitialSecurityNotificationSettingSync;
  typedef Message_InteractiveMessage InteractiveMessage;
  typedef Message_InteractiveResponseMessage InteractiveResponseMessage;
  typedef Message_InvoiceMessage InvoiceMessage;
  typedef Message_KeepInChatMessage KeepInChatMessage;
  typedef Message_ListMessage ListMessage;
  typedef Message_ListResponseMessage ListResponseMessage;
  typedef Message_LiveLocationMessage LiveLocationMessage;
  typedef Message_LocationMessage LocationMessage;
  typedef Message_OrderMessage OrderMessage;
  typedef Message_PaymentInviteMessage PaymentInviteMessage;
  typedef Message_PollCreationMessage PollCreationMessage;
  typedef Message_PollEncValue PollEncValue;
  typedef Message_PollUpdateMessageMetadata PollUpdateMessageMetadata;
  typedef Message_PollUpdateMessage PollUpdateMessage;
  typedef Message_PollVoteMessage PollVoteMessage;
  typedef Message_ProductMessage ProductMessage;
  typedef Message_ProtocolMessage ProtocolMessage;
  typedef Message_ReactionMessage ReactionMessage;
  typedef Message_RequestMediaUploadMessage RequestMediaUploadMessage;
  typedef Message_RequestMediaUploadResponseMessage RequestMediaUploadResponseMessage;
  typedef Message_RequestPaymentMessage RequestPaymentMessage;
  typedef Message_RequestPhoneNumberMessage RequestPhoneNumberMessage;
  typedef Message_SendPaymentMessage SendPaymentMessage;
  typedef Message_SenderKeyDistributionMessage SenderKeyDistributionMessage;
  typedef Message_StickerMessage StickerMessage;
  typedef Message_StickerSyncRMRMessage StickerSyncRMRMessage;
  typedef Message_TemplateButtonReplyMessage TemplateButtonReplyMessage;
  typedef Message_TemplateMessage TemplateMessage;
  typedef Message_VideoMessage VideoMessage;

  typedef Message_RmrSource RmrSource;
  static constexpr RmrSource FAVORITE_STICKER =
    Message_RmrSource_FAVORITE_STICKER;
  static constexpr RmrSource RECENT_STICKER =
    Message_RmrSource_RECENT_STICKER;
  static inline bool RmrSource_IsValid(int value) {
    return Message_RmrSource_IsValid(value);
  }
  static constexpr RmrSource RmrSource_MIN =
    Message_RmrSource_RmrSource_MIN;
  static constexpr RmrSource RmrSource_MAX =
    Message_RmrSource_RmrSource_MAX;
  static constexpr int RmrSource_ARRAYSIZE =
    Message_RmrSource_RmrSource_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RmrSource_descriptor() {
    return Message_RmrSource_descriptor();
  }
  template<typename T>
  static inline const std::string& RmrSource_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RmrSource>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RmrSource_Name.");
    return Message_RmrSource_Name(enum_t_value);
  }
  static inline bool RmrSource_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      RmrSource* value) {
    return Message_RmrSource_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kConversationFieldNumber = 1,
    kSenderKeyDistributionMessageFieldNumber = 2,
    kImageMessageFieldNumber = 3,
    kContactMessageFieldNumber = 4,
    kLocationMessageFieldNumber = 5,
    kExtendedTextMessageFieldNumber = 6,
    kDocumentMessageFieldNumber = 7,
    kAudioMessageFieldNumber = 8,
    kVideoMessageFieldNumber = 9,
    kCallFieldNumber = 10,
    kChatFieldNumber = 11,
    kProtocolMessageFieldNumber = 12,
    kContactsArrayMessageFieldNumber = 13,
    kHighlyStructuredMessageFieldNumber = 14,
    kFastRatchetKeySenderKeyDistributionMessageFieldNumber = 15,
    kSendPaymentMessageFieldNumber = 16,
    kLiveLocationMessageFieldNumber = 18,
    kRequestPaymentMessageFieldNumber = 22,
    kDeclinePaymentRequestMessageFieldNumber = 23,
    kCancelPaymentRequestMessageFieldNumber = 24,
    kTemplateMessageFieldNumber = 25,
    kStickerMessageFieldNumber = 26,
    kGroupInviteMessageFieldNumber = 28,
    kTemplateButtonReplyMessageFieldNumber = 29,
    kProductMessageFieldNumber = 30,
    kDeviceSentMessageFieldNumber = 31,
    kMessageContextInfoFieldNumber = 35,
    kListMessageFieldNumber = 36,
    kViewOnceMessageFieldNumber = 37,
    kOrderMessageFieldNumber = 38,
    kListResponseMessageFieldNumber = 39,
    kEphemeralMessageFieldNumber = 40,
    kInvoiceMessageFieldNumber = 41,
    kButtonsMessageFieldNumber = 42,
    kButtonsResponseMessageFieldNumber = 43,
    kPaymentInviteMessageFieldNumber = 44,
    kInteractiveMessageFieldNumber = 45,
    kReactionMessageFieldNumber = 46,
    kStickerSyncRmrMessageFieldNumber = 47,
    kInteractiveResponseMessageFieldNumber = 48,
    kPollCreationMessageFieldNumber = 49,
    kPollUpdateMessageFieldNumber = 50,
    kKeepInChatMessageFieldNumber = 51,
    kDocumentWithCaptionMessageFieldNumber = 53,
    kRequestPhoneNumberMessageFieldNumber = 54,
    kViewOnceMessageV2FieldNumber = 55,
  };
  // optional string conversation = 1;
  bool has_conversation() const;
  private:
  bool _internal_has_conversation() const;
  public:
  void clear_conversation();
  const std::string& conversation() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_conversation(ArgT0&& arg0, ArgT... args);
  std::string* mutable_conversation();
  PROTOBUF_NODISCARD std::string* release_conversation();
  void set_allocated_conversation(std::string* conversation);
  private:
  const std::string& _internal_conversation() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_conversation(const std::string& value);
  std::string* _internal_mutable_conversation();
  public:

  // optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
  bool has_senderkeydistributionmessage() const;
  private:
  bool _internal_has_senderkeydistributionmessage() const;
  public:
  void clear_senderkeydistributionmessage();
  const ::proto::Message_SenderKeyDistributionMessage& senderkeydistributionmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_senderkeydistributionmessage();
  ::proto::Message_SenderKeyDistributionMessage* mutable_senderkeydistributionmessage();
  void set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage);
  private:
  const ::proto::Message_SenderKeyDistributionMessage& _internal_senderkeydistributionmessage() const;
  ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_senderkeydistributionmessage();
  public:
  void unsafe_arena_set_allocated_senderkeydistributionmessage(
      ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage);
  ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_senderkeydistributionmessage();

  // optional .proto.Message.ImageMessage imageMessage = 3;
  bool has_imagemessage() const;
  private:
  bool _internal_has_imagemessage() const;
  public:
  void clear_imagemessage();
  const ::proto::Message_ImageMessage& imagemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ImageMessage* release_imagemessage();
  ::proto::Message_ImageMessage* mutable_imagemessage();
  void set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage);
  private:
  const ::proto::Message_ImageMessage& _internal_imagemessage() const;
  ::proto::Message_ImageMessage* _internal_mutable_imagemessage();
  public:
  void unsafe_arena_set_allocated_imagemessage(
      ::proto::Message_ImageMessage* imagemessage);
  ::proto::Message_ImageMessage* unsafe_arena_release_imagemessage();

  // optional .proto.Message.ContactMessage contactMessage = 4;
  bool has_contactmessage() const;
  private:
  bool _internal_has_contactmessage() const;
  public:
  void clear_contactmessage();
  const ::proto::Message_ContactMessage& contactmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ContactMessage* release_contactmessage();
  ::proto::Message_ContactMessage* mutable_contactmessage();
  void set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage);
  private:
  const ::proto::Message_ContactMessage& _internal_contactmessage() const;
  ::proto::Message_ContactMessage* _internal_mutable_contactmessage();
  public:
  void unsafe_arena_set_allocated_contactmessage(
      ::proto::Message_ContactMessage* contactmessage);
  ::proto::Message_ContactMessage* unsafe_arena_release_contactmessage();

  // optional .proto.Message.LocationMessage locationMessage = 5;
  bool has_locationmessage() const;
  private:
  bool _internal_has_locationmessage() const;
  public:
  void clear_locationmessage();
  const ::proto::Message_LocationMessage& locationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_LocationMessage* release_locationmessage();
  ::proto::Message_LocationMessage* mutable_locationmessage();
  void set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage);
  private:
  const ::proto::Message_LocationMessage& _internal_locationmessage() const;
  ::proto::Message_LocationMessage* _internal_mutable_locationmessage();
  public:
  void unsafe_arena_set_allocated_locationmessage(
      ::proto::Message_LocationMessage* locationmessage);
  ::proto::Message_LocationMessage* unsafe_arena_release_locationmessage();

  // optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
  bool has_extendedtextmessage() const;
  private:
  bool _internal_has_extendedtextmessage() const;
  public:
  void clear_extendedtextmessage();
  const ::proto::Message_ExtendedTextMessage& extendedtextmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ExtendedTextMessage* release_extendedtextmessage();
  ::proto::Message_ExtendedTextMessage* mutable_extendedtextmessage();
  void set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage);
  private:
  const ::proto::Message_ExtendedTextMessage& _internal_extendedtextmessage() const;
  ::proto::Message_ExtendedTextMessage* _internal_mutable_extendedtextmessage();
  public:
  void unsafe_arena_set_allocated_extendedtextmessage(
      ::proto::Message_ExtendedTextMessage* extendedtextmessage);
  ::proto::Message_ExtendedTextMessage* unsafe_arena_release_extendedtextmessage();

  // optional .proto.Message.DocumentMessage documentMessage = 7;
  bool has_documentmessage() const;
  private:
  bool _internal_has_documentmessage() const;
  public:
  void clear_documentmessage();
  const ::proto::Message_DocumentMessage& documentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DocumentMessage* release_documentmessage();
  ::proto::Message_DocumentMessage* mutable_documentmessage();
  void set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage);
  private:
  const ::proto::Message_DocumentMessage& _internal_documentmessage() const;
  ::proto::Message_DocumentMessage* _internal_mutable_documentmessage();
  public:
  void unsafe_arena_set_allocated_documentmessage(
      ::proto::Message_DocumentMessage* documentmessage);
  ::proto::Message_DocumentMessage* unsafe_arena_release_documentmessage();

  // optional .proto.Message.AudioMessage audioMessage = 8;
  bool has_audiomessage() const;
  private:
  bool _internal_has_audiomessage() const;
  public:
  void clear_audiomessage();
  const ::proto::Message_AudioMessage& audiomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_AudioMessage* release_audiomessage();
  ::proto::Message_AudioMessage* mutable_audiomessage();
  void set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage);
  private:
  const ::proto::Message_AudioMessage& _internal_audiomessage() const;
  ::proto::Message_AudioMessage* _internal_mutable_audiomessage();
  public:
  void unsafe_arena_set_allocated_audiomessage(
      ::proto::Message_AudioMessage* audiomessage);
  ::proto::Message_AudioMessage* unsafe_arena_release_audiomessage();

  // optional .proto.Message.VideoMessage videoMessage = 9;
  bool has_videomessage() const;
  private:
  bool _internal_has_videomessage() const;
  public:
  void clear_videomessage();
  const ::proto::Message_VideoMessage& videomessage() const;
  PROTOBUF_NODISCARD ::proto::Message_VideoMessage* release_videomessage();
  ::proto::Message_VideoMessage* mutable_videomessage();
  void set_allocated_videomessage(::proto::Message_VideoMessage* videomessage);
  private:
  const ::proto::Message_VideoMessage& _internal_videomessage() const;
  ::proto::Message_VideoMessage* _internal_mutable_videomessage();
  public:
  void unsafe_arena_set_allocated_videomessage(
      ::proto::Message_VideoMessage* videomessage);
  ::proto::Message_VideoMessage* unsafe_arena_release_videomessage();

  // optional .proto.Message.Call call = 10;
  bool has_call() const;
  private:
  bool _internal_has_call() const;
  public:
  void clear_call();
  const ::proto::Message_Call& call() const;
  PROTOBUF_NODISCARD ::proto::Message_Call* release_call();
  ::proto::Message_Call* mutable_call();
  void set_allocated_call(::proto::Message_Call* call);
  private:
  const ::proto::Message_Call& _internal_call() const;
  ::proto::Message_Call* _internal_mutable_call();
  public:
  void unsafe_arena_set_allocated_call(
      ::proto::Message_Call* call);
  ::proto::Message_Call* unsafe_arena_release_call();

  // optional .proto.Message.Chat chat = 11;
  bool has_chat() const;
  private:
  bool _internal_has_chat() const;
  public:
  void clear_chat();
  const ::proto::Message_Chat& chat() const;
  PROTOBUF_NODISCARD ::proto::Message_Chat* release_chat();
  ::proto::Message_Chat* mutable_chat();
  void set_allocated_chat(::proto::Message_Chat* chat);
  private:
  const ::proto::Message_Chat& _internal_chat() const;
  ::proto::Message_Chat* _internal_mutable_chat();
  public:
  void unsafe_arena_set_allocated_chat(
      ::proto::Message_Chat* chat);
  ::proto::Message_Chat* unsafe_arena_release_chat();

  // optional .proto.Message.ProtocolMessage protocolMessage = 12;
  bool has_protocolmessage() const;
  private:
  bool _internal_has_protocolmessage() const;
  public:
  void clear_protocolmessage();
  const ::proto::Message_ProtocolMessage& protocolmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ProtocolMessage* release_protocolmessage();
  ::proto::Message_ProtocolMessage* mutable_protocolmessage();
  void set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage);
  private:
  const ::proto::Message_ProtocolMessage& _internal_protocolmessage() const;
  ::proto::Message_ProtocolMessage* _internal_mutable_protocolmessage();
  public:
  void unsafe_arena_set_allocated_protocolmessage(
      ::proto::Message_ProtocolMessage* protocolmessage);
  ::proto::Message_ProtocolMessage* unsafe_arena_release_protocolmessage();

  // optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
  bool has_contactsarraymessage() const;
  private:
  bool _internal_has_contactsarraymessage() const;
  public:
  void clear_contactsarraymessage();
  const ::proto::Message_ContactsArrayMessage& contactsarraymessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ContactsArrayMessage* release_contactsarraymessage();
  ::proto::Message_ContactsArrayMessage* mutable_contactsarraymessage();
  void set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage);
  private:
  const ::proto::Message_ContactsArrayMessage& _internal_contactsarraymessage() const;
  ::proto::Message_ContactsArrayMessage* _internal_mutable_contactsarraymessage();
  public:
  void unsafe_arena_set_allocated_contactsarraymessage(
      ::proto::Message_ContactsArrayMessage* contactsarraymessage);
  ::proto::Message_ContactsArrayMessage* unsafe_arena_release_contactsarraymessage();

  // optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
  bool has_highlystructuredmessage() const;
  private:
  bool _internal_has_highlystructuredmessage() const;
  public:
  void clear_highlystructuredmessage();
  const ::proto::Message_HighlyStructuredMessage& highlystructuredmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_highlystructuredmessage();
  ::proto::Message_HighlyStructuredMessage* mutable_highlystructuredmessage();
  void set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_highlystructuredmessage() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_highlystructuredmessage();
  public:
  void unsafe_arena_set_allocated_highlystructuredmessage(
      ::proto::Message_HighlyStructuredMessage* highlystructuredmessage);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_highlystructuredmessage();

  // optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
  bool has_fastratchetkeysenderkeydistributionmessage() const;
  private:
  bool _internal_has_fastratchetkeysenderkeydistributionmessage() const;
  public:
  void clear_fastratchetkeysenderkeydistributionmessage();
  const ::proto::Message_SenderKeyDistributionMessage& fastratchetkeysenderkeydistributionmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_SenderKeyDistributionMessage* release_fastratchetkeysenderkeydistributionmessage();
  ::proto::Message_SenderKeyDistributionMessage* mutable_fastratchetkeysenderkeydistributionmessage();
  void set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage);
  private:
  const ::proto::Message_SenderKeyDistributionMessage& _internal_fastratchetkeysenderkeydistributionmessage() const;
  ::proto::Message_SenderKeyDistributionMessage* _internal_mutable_fastratchetkeysenderkeydistributionmessage();
  public:
  void unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage(
      ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage);
  ::proto::Message_SenderKeyDistributionMessage* unsafe_arena_release_fastratchetkeysenderkeydistributionmessage();

  // optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
  bool has_sendpaymentmessage() const;
  private:
  bool _internal_has_sendpaymentmessage() const;
  public:
  void clear_sendpaymentmessage();
  const ::proto::Message_SendPaymentMessage& sendpaymentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_SendPaymentMessage* release_sendpaymentmessage();
  ::proto::Message_SendPaymentMessage* mutable_sendpaymentmessage();
  void set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage);
  private:
  const ::proto::Message_SendPaymentMessage& _internal_sendpaymentmessage() const;
  ::proto::Message_SendPaymentMessage* _internal_mutable_sendpaymentmessage();
  public:
  void unsafe_arena_set_allocated_sendpaymentmessage(
      ::proto::Message_SendPaymentMessage* sendpaymentmessage);
  ::proto::Message_SendPaymentMessage* unsafe_arena_release_sendpaymentmessage();

  // optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
  bool has_livelocationmessage() const;
  private:
  bool _internal_has_livelocationmessage() const;
  public:
  void clear_livelocationmessage();
  const ::proto::Message_LiveLocationMessage& livelocationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_livelocationmessage();
  ::proto::Message_LiveLocationMessage* mutable_livelocationmessage();
  void set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage);
  private:
  const ::proto::Message_LiveLocationMessage& _internal_livelocationmessage() const;
  ::proto::Message_LiveLocationMessage* _internal_mutable_livelocationmessage();
  public:
  void unsafe_arena_set_allocated_livelocationmessage(
      ::proto::Message_LiveLocationMessage* livelocationmessage);
  ::proto::Message_LiveLocationMessage* unsafe_arena_release_livelocationmessage();

  // optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
  bool has_requestpaymentmessage() const;
  private:
  bool _internal_has_requestpaymentmessage() const;
  public:
  void clear_requestpaymentmessage();
  const ::proto::Message_RequestPaymentMessage& requestpaymentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_RequestPaymentMessage* release_requestpaymentmessage();
  ::proto::Message_RequestPaymentMessage* mutable_requestpaymentmessage();
  void set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage);
  private:
  const ::proto::Message_RequestPaymentMessage& _internal_requestpaymentmessage() const;
  ::proto::Message_RequestPaymentMessage* _internal_mutable_requestpaymentmessage();
  public:
  void unsafe_arena_set_allocated_requestpaymentmessage(
      ::proto::Message_RequestPaymentMessage* requestpaymentmessage);
  ::proto::Message_RequestPaymentMessage* unsafe_arena_release_requestpaymentmessage();

  // optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
  bool has_declinepaymentrequestmessage() const;
  private:
  bool _internal_has_declinepaymentrequestmessage() const;
  public:
  void clear_declinepaymentrequestmessage();
  const ::proto::Message_DeclinePaymentRequestMessage& declinepaymentrequestmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DeclinePaymentRequestMessage* release_declinepaymentrequestmessage();
  ::proto::Message_DeclinePaymentRequestMessage* mutable_declinepaymentrequestmessage();
  void set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage);
  private:
  const ::proto::Message_DeclinePaymentRequestMessage& _internal_declinepaymentrequestmessage() const;
  ::proto::Message_DeclinePaymentRequestMessage* _internal_mutable_declinepaymentrequestmessage();
  public:
  void unsafe_arena_set_allocated_declinepaymentrequestmessage(
      ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage);
  ::proto::Message_DeclinePaymentRequestMessage* unsafe_arena_release_declinepaymentrequestmessage();

  // optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
  bool has_cancelpaymentrequestmessage() const;
  private:
  bool _internal_has_cancelpaymentrequestmessage() const;
  public:
  void clear_cancelpaymentrequestmessage();
  const ::proto::Message_CancelPaymentRequestMessage& cancelpaymentrequestmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_CancelPaymentRequestMessage* release_cancelpaymentrequestmessage();
  ::proto::Message_CancelPaymentRequestMessage* mutable_cancelpaymentrequestmessage();
  void set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage);
  private:
  const ::proto::Message_CancelPaymentRequestMessage& _internal_cancelpaymentrequestmessage() const;
  ::proto::Message_CancelPaymentRequestMessage* _internal_mutable_cancelpaymentrequestmessage();
  public:
  void unsafe_arena_set_allocated_cancelpaymentrequestmessage(
      ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage);
  ::proto::Message_CancelPaymentRequestMessage* unsafe_arena_release_cancelpaymentrequestmessage();

  // optional .proto.Message.TemplateMessage templateMessage = 25;
  bool has_templatemessage() const;
  private:
  bool _internal_has_templatemessage() const;
  public:
  void clear_templatemessage();
  const ::proto::Message_TemplateMessage& templatemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateMessage* release_templatemessage();
  ::proto::Message_TemplateMessage* mutable_templatemessage();
  void set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage);
  private:
  const ::proto::Message_TemplateMessage& _internal_templatemessage() const;
  ::proto::Message_TemplateMessage* _internal_mutable_templatemessage();
  public:
  void unsafe_arena_set_allocated_templatemessage(
      ::proto::Message_TemplateMessage* templatemessage);
  ::proto::Message_TemplateMessage* unsafe_arena_release_templatemessage();

  // optional .proto.Message.StickerMessage stickerMessage = 26;
  bool has_stickermessage() const;
  private:
  bool _internal_has_stickermessage() const;
  public:
  void clear_stickermessage();
  const ::proto::Message_StickerMessage& stickermessage() const;
  PROTOBUF_NODISCARD ::proto::Message_StickerMessage* release_stickermessage();
  ::proto::Message_StickerMessage* mutable_stickermessage();
  void set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage);
  private:
  const ::proto::Message_StickerMessage& _internal_stickermessage() const;
  ::proto::Message_StickerMessage* _internal_mutable_stickermessage();
  public:
  void unsafe_arena_set_allocated_stickermessage(
      ::proto::Message_StickerMessage* stickermessage);
  ::proto::Message_StickerMessage* unsafe_arena_release_stickermessage();

  // optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
  bool has_groupinvitemessage() const;
  private:
  bool _internal_has_groupinvitemessage() const;
  public:
  void clear_groupinvitemessage();
  const ::proto::Message_GroupInviteMessage& groupinvitemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_GroupInviteMessage* release_groupinvitemessage();
  ::proto::Message_GroupInviteMessage* mutable_groupinvitemessage();
  void set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage);
  private:
  const ::proto::Message_GroupInviteMessage& _internal_groupinvitemessage() const;
  ::proto::Message_GroupInviteMessage* _internal_mutable_groupinvitemessage();
  public:
  void unsafe_arena_set_allocated_groupinvitemessage(
      ::proto::Message_GroupInviteMessage* groupinvitemessage);
  ::proto::Message_GroupInviteMessage* unsafe_arena_release_groupinvitemessage();

  // optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
  bool has_templatebuttonreplymessage() const;
  private:
  bool _internal_has_templatebuttonreplymessage() const;
  public:
  void clear_templatebuttonreplymessage();
  const ::proto::Message_TemplateButtonReplyMessage& templatebuttonreplymessage() const;
  PROTOBUF_NODISCARD ::proto::Message_TemplateButtonReplyMessage* release_templatebuttonreplymessage();
  ::proto::Message_TemplateButtonReplyMessage* mutable_templatebuttonreplymessage();
  void set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage);
  private:
  const ::proto::Message_TemplateButtonReplyMessage& _internal_templatebuttonreplymessage() const;
  ::proto::Message_TemplateButtonReplyMessage* _internal_mutable_templatebuttonreplymessage();
  public:
  void unsafe_arena_set_allocated_templatebuttonreplymessage(
      ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage);
  ::proto::Message_TemplateButtonReplyMessage* unsafe_arena_release_templatebuttonreplymessage();

  // optional .proto.Message.ProductMessage productMessage = 30;
  bool has_productmessage() const;
  private:
  bool _internal_has_productmessage() const;
  public:
  void clear_productmessage();
  const ::proto::Message_ProductMessage& productmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ProductMessage* release_productmessage();
  ::proto::Message_ProductMessage* mutable_productmessage();
  void set_allocated_productmessage(::proto::Message_ProductMessage* productmessage);
  private:
  const ::proto::Message_ProductMessage& _internal_productmessage() const;
  ::proto::Message_ProductMessage* _internal_mutable_productmessage();
  public:
  void unsafe_arena_set_allocated_productmessage(
      ::proto::Message_ProductMessage* productmessage);
  ::proto::Message_ProductMessage* unsafe_arena_release_productmessage();

  // optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
  bool has_devicesentmessage() const;
  private:
  bool _internal_has_devicesentmessage() const;
  public:
  void clear_devicesentmessage();
  const ::proto::Message_DeviceSentMessage& devicesentmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_DeviceSentMessage* release_devicesentmessage();
  ::proto::Message_DeviceSentMessage* mutable_devicesentmessage();
  void set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage);
  private:
  const ::proto::Message_DeviceSentMessage& _internal_devicesentmessage() const;
  ::proto::Message_DeviceSentMessage* _internal_mutable_devicesentmessage();
  public:
  void unsafe_arena_set_allocated_devicesentmessage(
      ::proto::Message_DeviceSentMessage* devicesentmessage);
  ::proto::Message_DeviceSentMessage* unsafe_arena_release_devicesentmessage();

  // optional .proto.MessageContextInfo messageContextInfo = 35;
  bool has_messagecontextinfo() const;
  private:
  bool _internal_has_messagecontextinfo() const;
  public:
  void clear_messagecontextinfo();
  const ::proto::MessageContextInfo& messagecontextinfo() const;
  PROTOBUF_NODISCARD ::proto::MessageContextInfo* release_messagecontextinfo();
  ::proto::MessageContextInfo* mutable_messagecontextinfo();
  void set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo);
  private:
  const ::proto::MessageContextInfo& _internal_messagecontextinfo() const;
  ::proto::MessageContextInfo* _internal_mutable_messagecontextinfo();
  public:
  void unsafe_arena_set_allocated_messagecontextinfo(
      ::proto::MessageContextInfo* messagecontextinfo);
  ::proto::MessageContextInfo* unsafe_arena_release_messagecontextinfo();

  // optional .proto.Message.ListMessage listMessage = 36;
  bool has_listmessage() const;
  private:
  bool _internal_has_listmessage() const;
  public:
  void clear_listmessage();
  const ::proto::Message_ListMessage& listmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ListMessage* release_listmessage();
  ::proto::Message_ListMessage* mutable_listmessage();
  void set_allocated_listmessage(::proto::Message_ListMessage* listmessage);
  private:
  const ::proto::Message_ListMessage& _internal_listmessage() const;
  ::proto::Message_ListMessage* _internal_mutable_listmessage();
  public:
  void unsafe_arena_set_allocated_listmessage(
      ::proto::Message_ListMessage* listmessage);
  ::proto::Message_ListMessage* unsafe_arena_release_listmessage();

  // optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
  bool has_viewoncemessage() const;
  private:
  bool _internal_has_viewoncemessage() const;
  public:
  void clear_viewoncemessage();
  const ::proto::Message_FutureProofMessage& viewoncemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessage();
  ::proto::Message_FutureProofMessage* mutable_viewoncemessage();
  void set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage);
  private:
  const ::proto::Message_FutureProofMessage& _internal_viewoncemessage() const;
  ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessage();
  public:
  void unsafe_arena_set_allocated_viewoncemessage(
      ::proto::Message_FutureProofMessage* viewoncemessage);
  ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessage();

  // optional .proto.Message.OrderMessage orderMessage = 38;
  bool has_ordermessage() const;
  private:
  bool _internal_has_ordermessage() const;
  public:
  void clear_ordermessage();
  const ::proto::Message_OrderMessage& ordermessage() const;
  PROTOBUF_NODISCARD ::proto::Message_OrderMessage* release_ordermessage();
  ::proto::Message_OrderMessage* mutable_ordermessage();
  void set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage);
  private:
  const ::proto::Message_OrderMessage& _internal_ordermessage() const;
  ::proto::Message_OrderMessage* _internal_mutable_ordermessage();
  public:
  void unsafe_arena_set_allocated_ordermessage(
      ::proto::Message_OrderMessage* ordermessage);
  ::proto::Message_OrderMessage* unsafe_arena_release_ordermessage();

  // optional .proto.Message.ListResponseMessage listResponseMessage = 39;
  bool has_listresponsemessage() const;
  private:
  bool _internal_has_listresponsemessage() const;
  public:
  void clear_listresponsemessage();
  const ::proto::Message_ListResponseMessage& listresponsemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ListResponseMessage* release_listresponsemessage();
  ::proto::Message_ListResponseMessage* mutable_listresponsemessage();
  void set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage);
  private:
  const ::proto::Message_ListResponseMessage& _internal_listresponsemessage() const;
  ::proto::Message_ListResponseMessage* _internal_mutable_listresponsemessage();
  public:
  void unsafe_arena_set_allocated_listresponsemessage(
      ::proto::Message_ListResponseMessage* listresponsemessage);
  ::proto::Message_ListResponseMessage* unsafe_arena_release_listresponsemessage();

  // optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
  bool has_ephemeralmessage() const;
  private:
  bool _internal_has_ephemeralmessage() const;
  public:
  void clear_ephemeralmessage();
  const ::proto::Message_FutureProofMessage& ephemeralmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_ephemeralmessage();
  ::proto::Message_FutureProofMessage* mutable_ephemeralmessage();
  void set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage);
  private:
  const ::proto::Message_FutureProofMessage& _internal_ephemeralmessage() const;
  ::proto::Message_FutureProofMessage* _internal_mutable_ephemeralmessage();
  public:
  void unsafe_arena_set_allocated_ephemeralmessage(
      ::proto::Message_FutureProofMessage* ephemeralmessage);
  ::proto::Message_FutureProofMessage* unsafe_arena_release_ephemeralmessage();

  // optional .proto.Message.InvoiceMessage invoiceMessage = 41;
  bool has_invoicemessage() const;
  private:
  bool _internal_has_invoicemessage() const;
  public:
  void clear_invoicemessage();
  const ::proto::Message_InvoiceMessage& invoicemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InvoiceMessage* release_invoicemessage();
  ::proto::Message_InvoiceMessage* mutable_invoicemessage();
  void set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage);
  private:
  const ::proto::Message_InvoiceMessage& _internal_invoicemessage() const;
  ::proto::Message_InvoiceMessage* _internal_mutable_invoicemessage();
  public:
  void unsafe_arena_set_allocated_invoicemessage(
      ::proto::Message_InvoiceMessage* invoicemessage);
  ::proto::Message_InvoiceMessage* unsafe_arena_release_invoicemessage();

  // optional .proto.Message.ButtonsMessage buttonsMessage = 42;
  bool has_buttonsmessage() const;
  private:
  bool _internal_has_buttonsmessage() const;
  public:
  void clear_buttonsmessage();
  const ::proto::Message_ButtonsMessage& buttonsmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ButtonsMessage* release_buttonsmessage();
  ::proto::Message_ButtonsMessage* mutable_buttonsmessage();
  void set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage);
  private:
  const ::proto::Message_ButtonsMessage& _internal_buttonsmessage() const;
  ::proto::Message_ButtonsMessage* _internal_mutable_buttonsmessage();
  public:
  void unsafe_arena_set_allocated_buttonsmessage(
      ::proto::Message_ButtonsMessage* buttonsmessage);
  ::proto::Message_ButtonsMessage* unsafe_arena_release_buttonsmessage();

  // optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
  bool has_buttonsresponsemessage() const;
  private:
  bool _internal_has_buttonsresponsemessage() const;
  public:
  void clear_buttonsresponsemessage();
  const ::proto::Message_ButtonsResponseMessage& buttonsresponsemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ButtonsResponseMessage* release_buttonsresponsemessage();
  ::proto::Message_ButtonsResponseMessage* mutable_buttonsresponsemessage();
  void set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage);
  private:
  const ::proto::Message_ButtonsResponseMessage& _internal_buttonsresponsemessage() const;
  ::proto::Message_ButtonsResponseMessage* _internal_mutable_buttonsresponsemessage();
  public:
  void unsafe_arena_set_allocated_buttonsresponsemessage(
      ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage);
  ::proto::Message_ButtonsResponseMessage* unsafe_arena_release_buttonsresponsemessage();

  // optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
  bool has_paymentinvitemessage() const;
  private:
  bool _internal_has_paymentinvitemessage() const;
  public:
  void clear_paymentinvitemessage();
  const ::proto::Message_PaymentInviteMessage& paymentinvitemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_PaymentInviteMessage* release_paymentinvitemessage();
  ::proto::Message_PaymentInviteMessage* mutable_paymentinvitemessage();
  void set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage);
  private:
  const ::proto::Message_PaymentInviteMessage& _internal_paymentinvitemessage() const;
  ::proto::Message_PaymentInviteMessage* _internal_mutable_paymentinvitemessage();
  public:
  void unsafe_arena_set_allocated_paymentinvitemessage(
      ::proto::Message_PaymentInviteMessage* paymentinvitemessage);
  ::proto::Message_PaymentInviteMessage* unsafe_arena_release_paymentinvitemessage();

  // optional .proto.Message.InteractiveMessage interactiveMessage = 45;
  bool has_interactivemessage() const;
  private:
  bool _internal_has_interactivemessage() const;
  public:
  void clear_interactivemessage();
  const ::proto::Message_InteractiveMessage& interactivemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveMessage* release_interactivemessage();
  ::proto::Message_InteractiveMessage* mutable_interactivemessage();
  void set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage);
  private:
  const ::proto::Message_InteractiveMessage& _internal_interactivemessage() const;
  ::proto::Message_InteractiveMessage* _internal_mutable_interactivemessage();
  public:
  void unsafe_arena_set_allocated_interactivemessage(
      ::proto::Message_InteractiveMessage* interactivemessage);
  ::proto::Message_InteractiveMessage* unsafe_arena_release_interactivemessage();

  // optional .proto.Message.ReactionMessage reactionMessage = 46;
  bool has_reactionmessage() const;
  private:
  bool _internal_has_reactionmessage() const;
  public:
  void clear_reactionmessage();
  const ::proto::Message_ReactionMessage& reactionmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_ReactionMessage* release_reactionmessage();
  ::proto::Message_ReactionMessage* mutable_reactionmessage();
  void set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage);
  private:
  const ::proto::Message_ReactionMessage& _internal_reactionmessage() const;
  ::proto::Message_ReactionMessage* _internal_mutable_reactionmessage();
  public:
  void unsafe_arena_set_allocated_reactionmessage(
      ::proto::Message_ReactionMessage* reactionmessage);
  ::proto::Message_ReactionMessage* unsafe_arena_release_reactionmessage();

  // optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
  bool has_stickersyncrmrmessage() const;
  private:
  bool _internal_has_stickersyncrmrmessage() const;
  public:
  void clear_stickersyncrmrmessage();
  const ::proto::Message_StickerSyncRMRMessage& stickersyncrmrmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_StickerSyncRMRMessage* release_stickersyncrmrmessage();
  ::proto::Message_StickerSyncRMRMessage* mutable_stickersyncrmrmessage();
  void set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage);
  private:
  const ::proto::Message_StickerSyncRMRMessage& _internal_stickersyncrmrmessage() const;
  ::proto::Message_StickerSyncRMRMessage* _internal_mutable_stickersyncrmrmessage();
  public:
  void unsafe_arena_set_allocated_stickersyncrmrmessage(
      ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage);
  ::proto::Message_StickerSyncRMRMessage* unsafe_arena_release_stickersyncrmrmessage();

  // optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
  bool has_interactiveresponsemessage() const;
  private:
  bool _internal_has_interactiveresponsemessage() const;
  public:
  void clear_interactiveresponsemessage();
  const ::proto::Message_InteractiveResponseMessage& interactiveresponsemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_InteractiveResponseMessage* release_interactiveresponsemessage();
  ::proto::Message_InteractiveResponseMessage* mutable_interactiveresponsemessage();
  void set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage);
  private:
  const ::proto::Message_InteractiveResponseMessage& _internal_interactiveresponsemessage() const;
  ::proto::Message_InteractiveResponseMessage* _internal_mutable_interactiveresponsemessage();
  public:
  void unsafe_arena_set_allocated_interactiveresponsemessage(
      ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage);
  ::proto::Message_InteractiveResponseMessage* unsafe_arena_release_interactiveresponsemessage();

  // optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
  bool has_pollcreationmessage() const;
  private:
  bool _internal_has_pollcreationmessage() const;
  public:
  void clear_pollcreationmessage();
  const ::proto::Message_PollCreationMessage& pollcreationmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_PollCreationMessage* release_pollcreationmessage();
  ::proto::Message_PollCreationMessage* mutable_pollcreationmessage();
  void set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage);
  private:
  const ::proto::Message_PollCreationMessage& _internal_pollcreationmessage() const;
  ::proto::Message_PollCreationMessage* _internal_mutable_pollcreationmessage();
  public:
  void unsafe_arena_set_allocated_pollcreationmessage(
      ::proto::Message_PollCreationMessage* pollcreationmessage);
  ::proto::Message_PollCreationMessage* unsafe_arena_release_pollcreationmessage();

  // optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
  bool has_pollupdatemessage() const;
  private:
  bool _internal_has_pollupdatemessage() const;
  public:
  void clear_pollupdatemessage();
  const ::proto::Message_PollUpdateMessage& pollupdatemessage() const;
  PROTOBUF_NODISCARD ::proto::Message_PollUpdateMessage* release_pollupdatemessage();
  ::proto::Message_PollUpdateMessage* mutable_pollupdatemessage();
  void set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage);
  private:
  const ::proto::Message_PollUpdateMessage& _internal_pollupdatemessage() const;
  ::proto::Message_PollUpdateMessage* _internal_mutable_pollupdatemessage();
  public:
  void unsafe_arena_set_allocated_pollupdatemessage(
      ::proto::Message_PollUpdateMessage* pollupdatemessage);
  ::proto::Message_PollUpdateMessage* unsafe_arena_release_pollupdatemessage();

  // optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
  bool has_keepinchatmessage() const;
  private:
  bool _internal_has_keepinchatmessage() const;
  public:
  void clear_keepinchatmessage();
  const ::proto::Message_KeepInChatMessage& keepinchatmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_KeepInChatMessage* release_keepinchatmessage();
  ::proto::Message_KeepInChatMessage* mutable_keepinchatmessage();
  void set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage);
  private:
  const ::proto::Message_KeepInChatMessage& _internal_keepinchatmessage() const;
  ::proto::Message_KeepInChatMessage* _internal_mutable_keepinchatmessage();
  public:
  void unsafe_arena_set_allocated_keepinchatmessage(
      ::proto::Message_KeepInChatMessage* keepinchatmessage);
  ::proto::Message_KeepInChatMessage* unsafe_arena_release_keepinchatmessage();

  // optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
  bool has_documentwithcaptionmessage() const;
  private:
  bool _internal_has_documentwithcaptionmessage() const;
  public:
  void clear_documentwithcaptionmessage();
  const ::proto::Message_FutureProofMessage& documentwithcaptionmessage() const;
  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_documentwithcaptionmessage();
  ::proto::Message_FutureProofMessage* mutable_documentwithcaptionmessage();
  void set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage);
  private:
  const ::proto::Message_FutureProofMessage& _internal_documentwithcaptionmessage() const;
  ::proto::Message_FutureProofMessage* _internal_mutable_documentwithcaptionmessage();
  public:
  void unsafe_arena_set_allocated_documentwithcaptionmessage(
      ::proto::Message_FutureProofMessage* documentwithcaptionmessage);
  ::proto::Message_FutureProofMessage* unsafe_arena_release_documentwithcaptionmessage();

  // optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
  bool has_requestphonenumbermessage() const;
  private:
  bool _internal_has_requestphonenumbermessage() const;
  public:
  void clear_requestphonenumbermessage();
  const ::proto::Message_RequestPhoneNumberMessage& requestphonenumbermessage() const;
  PROTOBUF_NODISCARD ::proto::Message_RequestPhoneNumberMessage* release_requestphonenumbermessage();
  ::proto::Message_RequestPhoneNumberMessage* mutable_requestphonenumbermessage();
  void set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage);
  private:
  const ::proto::Message_RequestPhoneNumberMessage& _internal_requestphonenumbermessage() const;
  ::proto::Message_RequestPhoneNumberMessage* _internal_mutable_requestphonenumbermessage();
  public:
  void unsafe_arena_set_allocated_requestphonenumbermessage(
      ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage);
  ::proto::Message_RequestPhoneNumberMessage* unsafe_arena_release_requestphonenumbermessage();

  // optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
  bool has_viewoncemessagev2() const;
  private:
  bool _internal_has_viewoncemessagev2() const;
  public:
  void clear_viewoncemessagev2();
  const ::proto::Message_FutureProofMessage& viewoncemessagev2() const;
  PROTOBUF_NODISCARD ::proto::Message_FutureProofMessage* release_viewoncemessagev2();
  ::proto::Message_FutureProofMessage* mutable_viewoncemessagev2();
  void set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2);
  private:
  const ::proto::Message_FutureProofMessage& _internal_viewoncemessagev2() const;
  ::proto::Message_FutureProofMessage* _internal_mutable_viewoncemessagev2();
  public:
  void unsafe_arena_set_allocated_viewoncemessagev2(
      ::proto::Message_FutureProofMessage* viewoncemessagev2);
  ::proto::Message_FutureProofMessage* unsafe_arena_release_viewoncemessagev2();

  // @@protoc_insertion_point(class_scope:proto.Message)
 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<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr conversation_;
    ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage_;
    ::proto::Message_ImageMessage* imagemessage_;
    ::proto::Message_ContactMessage* contactmessage_;
    ::proto::Message_LocationMessage* locationmessage_;
    ::proto::Message_ExtendedTextMessage* extendedtextmessage_;
    ::proto::Message_DocumentMessage* documentmessage_;
    ::proto::Message_AudioMessage* audiomessage_;
    ::proto::Message_VideoMessage* videomessage_;
    ::proto::Message_Call* call_;
    ::proto::Message_Chat* chat_;
    ::proto::Message_ProtocolMessage* protocolmessage_;
    ::proto::Message_ContactsArrayMessage* contactsarraymessage_;
    ::proto::Message_HighlyStructuredMessage* highlystructuredmessage_;
    ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage_;
    ::proto::Message_SendPaymentMessage* sendpaymentmessage_;
    ::proto::Message_LiveLocationMessage* livelocationmessage_;
    ::proto::Message_RequestPaymentMessage* requestpaymentmessage_;
    ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage_;
    ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage_;
    ::proto::Message_TemplateMessage* templatemessage_;
    ::proto::Message_StickerMessage* stickermessage_;
    ::proto::Message_GroupInviteMessage* groupinvitemessage_;
    ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage_;
    ::proto::Message_ProductMessage* productmessage_;
    ::proto::Message_DeviceSentMessage* devicesentmessage_;
    ::proto::MessageContextInfo* messagecontextinfo_;
    ::proto::Message_ListMessage* listmessage_;
    ::proto::Message_FutureProofMessage* viewoncemessage_;
    ::proto::Message_OrderMessage* ordermessage_;
    ::proto::Message_ListResponseMessage* listresponsemessage_;
    ::proto::Message_FutureProofMessage* ephemeralmessage_;
    ::proto::Message_InvoiceMessage* invoicemessage_;
    ::proto::Message_ButtonsMessage* buttonsmessage_;
    ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage_;
    ::proto::Message_PaymentInviteMessage* paymentinvitemessage_;
    ::proto::Message_InteractiveMessage* interactivemessage_;
    ::proto::Message_ReactionMessage* reactionmessage_;
    ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage_;
    ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage_;
    ::proto::Message_PollCreationMessage* pollcreationmessage_;
    ::proto::Message_PollUpdateMessage* pollupdatemessage_;
    ::proto::Message_KeepInChatMessage* keepinchatmessage_;
    ::proto::Message_FutureProofMessage* documentwithcaptionmessage_;
    ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage_;
    ::proto::Message_FutureProofMessage* viewoncemessagev2_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class MessageContextInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageContextInfo) */ {
 public:
  inline MessageContextInfo() : MessageContextInfo(nullptr) {}
  ~MessageContextInfo() override;
  explicit PROTOBUF_CONSTEXPR MessageContextInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MessageContextInfo(const MessageContextInfo& from);
  MessageContextInfo(MessageContextInfo&& from) noexcept
    : MessageContextInfo() {
    *this = ::std::move(from);
  }

  inline MessageContextInfo& operator=(const MessageContextInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline MessageContextInfo& operator=(MessageContextInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MessageContextInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const MessageContextInfo* internal_default_instance() {
    return reinterpret_cast<const MessageContextInfo*>(
               &_MessageContextInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    138;

  friend void swap(MessageContextInfo& a, MessageContextInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(MessageContextInfo* 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(MessageContextInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MessageContextInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MessageContextInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MessageContextInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MessageContextInfo& from) {
    MessageContextInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MessageContextInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.MessageContextInfo";
  }
  protected:
  explicit MessageContextInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageSecretFieldNumber = 3,
    kPaddingBytesFieldNumber = 4,
    kDeviceListMetadataFieldNumber = 1,
    kDeviceListMetadataVersionFieldNumber = 2,
  };
  // optional bytes messageSecret = 3;
  bool has_messagesecret() const;
  private:
  bool _internal_has_messagesecret() const;
  public:
  void clear_messagesecret();
  const std::string& messagesecret() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_messagesecret(ArgT0&& arg0, ArgT... args);
  std::string* mutable_messagesecret();
  PROTOBUF_NODISCARD std::string* release_messagesecret();
  void set_allocated_messagesecret(std::string* messagesecret);
  private:
  const std::string& _internal_messagesecret() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
  std::string* _internal_mutable_messagesecret();
  public:

  // optional bytes paddingBytes = 4;
  bool has_paddingbytes() const;
  private:
  bool _internal_has_paddingbytes() const;
  public:
  void clear_paddingbytes();
  const std::string& paddingbytes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_paddingbytes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_paddingbytes();
  PROTOBUF_NODISCARD std::string* release_paddingbytes();
  void set_allocated_paddingbytes(std::string* paddingbytes);
  private:
  const std::string& _internal_paddingbytes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paddingbytes(const std::string& value);
  std::string* _internal_mutable_paddingbytes();
  public:

  // optional .proto.DeviceListMetadata deviceListMetadata = 1;
  bool has_devicelistmetadata() const;
  private:
  bool _internal_has_devicelistmetadata() const;
  public:
  void clear_devicelistmetadata();
  const ::proto::DeviceListMetadata& devicelistmetadata() const;
  PROTOBUF_NODISCARD ::proto::DeviceListMetadata* release_devicelistmetadata();
  ::proto::DeviceListMetadata* mutable_devicelistmetadata();
  void set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata);
  private:
  const ::proto::DeviceListMetadata& _internal_devicelistmetadata() const;
  ::proto::DeviceListMetadata* _internal_mutable_devicelistmetadata();
  public:
  void unsafe_arena_set_allocated_devicelistmetadata(
      ::proto::DeviceListMetadata* devicelistmetadata);
  ::proto::DeviceListMetadata* unsafe_arena_release_devicelistmetadata();

  // optional int32 deviceListMetadataVersion = 2;
  bool has_devicelistmetadataversion() const;
  private:
  bool _internal_has_devicelistmetadataversion() const;
  public:
  void clear_devicelistmetadataversion();
  int32_t devicelistmetadataversion() const;
  void set_devicelistmetadataversion(int32_t value);
  private:
  int32_t _internal_devicelistmetadataversion() const;
  void _internal_set_devicelistmetadataversion(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.MessageContextInfo)
 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 messagesecret_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paddingbytes_;
    ::proto::DeviceListMetadata* devicelistmetadata_;
    int32_t devicelistmetadataversion_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class MessageKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MessageKey) */ {
 public:
  inline MessageKey() : MessageKey(nullptr) {}
  ~MessageKey() override;
  explicit PROTOBUF_CONSTEXPR MessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MessageKey(const MessageKey& from);
  MessageKey(MessageKey&& from) noexcept
    : MessageKey() {
    *this = ::std::move(from);
  }

  inline MessageKey& operator=(const MessageKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline MessageKey& operator=(MessageKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MessageKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const MessageKey* internal_default_instance() {
    return reinterpret_cast<const MessageKey*>(
               &_MessageKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    139;

  friend void swap(MessageKey& a, MessageKey& b) {
    a.Swap(&b);
  }
  inline void Swap(MessageKey* 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(MessageKey* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MessageKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MessageKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MessageKey& from) {
    MessageKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MessageKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.MessageKey";
  }
  protected:
  explicit MessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRemoteJidFieldNumber = 1,
    kIdFieldNumber = 3,
    kParticipantFieldNumber = 4,
    kFromMeFieldNumber = 2,
  };
  // optional string remoteJid = 1;
  bool has_remotejid() const;
  private:
  bool _internal_has_remotejid() const;
  public:
  void clear_remotejid();
  const std::string& remotejid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remotejid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remotejid();
  PROTOBUF_NODISCARD std::string* release_remotejid();
  void set_allocated_remotejid(std::string* remotejid);
  private:
  const std::string& _internal_remotejid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remotejid(const std::string& value);
  std::string* _internal_mutable_remotejid();
  public:

  // optional string id = 3;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional string participant = 4;
  bool has_participant() const;
  private:
  bool _internal_has_participant() const;
  public:
  void clear_participant();
  const std::string& participant() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_participant(ArgT0&& arg0, ArgT... args);
  std::string* mutable_participant();
  PROTOBUF_NODISCARD std::string* release_participant();
  void set_allocated_participant(std::string* participant);
  private:
  const std::string& _internal_participant() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
  std::string* _internal_mutable_participant();
  public:

  // optional bool fromMe = 2;
  bool has_fromme() const;
  private:
  bool _internal_has_fromme() const;
  public:
  void clear_fromme();
  bool fromme() const;
  void set_fromme(bool value);
  private:
  bool _internal_fromme() const;
  void _internal_set_fromme(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.MessageKey)
 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 remotejid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
    bool fromme_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Money final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Money) */ {
 public:
  inline Money() : Money(nullptr) {}
  ~Money() override;
  explicit PROTOBUF_CONSTEXPR Money(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Money(const Money& from);
  Money(Money&& from) noexcept
    : Money() {
    *this = ::std::move(from);
  }

  inline Money& operator=(const Money& from) {
    CopyFrom(from);
    return *this;
  }
  inline Money& operator=(Money&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Money& default_instance() {
    return *internal_default_instance();
  }
  static inline const Money* internal_default_instance() {
    return reinterpret_cast<const Money*>(
               &_Money_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    140;

  friend void swap(Money& a, Money& b) {
    a.Swap(&b);
  }
  inline void Swap(Money* 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(Money* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Money* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Money>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Money& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Money& from) {
    Money::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Money* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Money";
  }
  protected:
  explicit Money(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCurrencyCodeFieldNumber = 3,
    kValueFieldNumber = 1,
    kOffsetFieldNumber = 2,
  };
  // optional string currencyCode = 3;
  bool has_currencycode() const;
  private:
  bool _internal_has_currencycode() const;
  public:
  void clear_currencycode();
  const std::string& currencycode() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_currencycode(ArgT0&& arg0, ArgT... args);
  std::string* mutable_currencycode();
  PROTOBUF_NODISCARD std::string* release_currencycode();
  void set_allocated_currencycode(std::string* currencycode);
  private:
  const std::string& _internal_currencycode() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currencycode(const std::string& value);
  std::string* _internal_mutable_currencycode();
  public:

  // optional int64 value = 1;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  int64_t value() const;
  void set_value(int64_t value);
  private:
  int64_t _internal_value() const;
  void _internal_set_value(int64_t value);
  public:

  // optional uint32 offset = 2;
  bool has_offset() const;
  private:
  bool _internal_has_offset() const;
  public:
  void clear_offset();
  uint32_t offset() const;
  void set_offset(uint32_t value);
  private:
  uint32_t _internal_offset() const;
  void _internal_set_offset(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Money)
 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 currencycode_;
    int64_t value_;
    uint32_t offset_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class MsgOpaqueData_PollOption final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData.PollOption) */ {
 public:
  inline MsgOpaqueData_PollOption() : MsgOpaqueData_PollOption(nullptr) {}
  ~MsgOpaqueData_PollOption() override;
  explicit PROTOBUF_CONSTEXPR MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MsgOpaqueData_PollOption(const MsgOpaqueData_PollOption& from);
  MsgOpaqueData_PollOption(MsgOpaqueData_PollOption&& from) noexcept
    : MsgOpaqueData_PollOption() {
    *this = ::std::move(from);
  }

  inline MsgOpaqueData_PollOption& operator=(const MsgOpaqueData_PollOption& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgOpaqueData_PollOption& operator=(MsgOpaqueData_PollOption&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MsgOpaqueData_PollOption& default_instance() {
    return *internal_default_instance();
  }
  static inline const MsgOpaqueData_PollOption* internal_default_instance() {
    return reinterpret_cast<const MsgOpaqueData_PollOption*>(
               &_MsgOpaqueData_PollOption_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    141;

  friend void swap(MsgOpaqueData_PollOption& a, MsgOpaqueData_PollOption& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgOpaqueData_PollOption* 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(MsgOpaqueData_PollOption* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MsgOpaqueData_PollOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MsgOpaqueData_PollOption>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MsgOpaqueData_PollOption& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MsgOpaqueData_PollOption& from) {
    MsgOpaqueData_PollOption::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MsgOpaqueData_PollOption* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.MsgOpaqueData.PollOption";
  }
  protected:
  explicit MsgOpaqueData_PollOption(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
  };
  // optional string name = 1;
  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:proto.MsgOpaqueData.PollOption)
 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 name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class MsgOpaqueData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgOpaqueData) */ {
 public:
  inline MsgOpaqueData() : MsgOpaqueData(nullptr) {}
  ~MsgOpaqueData() override;
  explicit PROTOBUF_CONSTEXPR MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MsgOpaqueData(const MsgOpaqueData& from);
  MsgOpaqueData(MsgOpaqueData&& from) noexcept
    : MsgOpaqueData() {
    *this = ::std::move(from);
  }

  inline MsgOpaqueData& operator=(const MsgOpaqueData& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgOpaqueData& operator=(MsgOpaqueData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MsgOpaqueData& default_instance() {
    return *internal_default_instance();
  }
  static inline const MsgOpaqueData* internal_default_instance() {
    return reinterpret_cast<const MsgOpaqueData*>(
               &_MsgOpaqueData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    142;

  friend void swap(MsgOpaqueData& a, MsgOpaqueData& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgOpaqueData* 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(MsgOpaqueData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MsgOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MsgOpaqueData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MsgOpaqueData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MsgOpaqueData& from) {
    MsgOpaqueData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MsgOpaqueData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.MsgOpaqueData";
  }
  protected:
  explicit MsgOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef MsgOpaqueData_PollOption PollOption;

  // accessors -------------------------------------------------------

  enum : int {
    kPollOptionsFieldNumber = 18,
    kBodyFieldNumber = 1,
    kCaptionFieldNumber = 3,
    kPaymentNoteMsgBodyFieldNumber = 9,
    kCanonicalUrlFieldNumber = 10,
    kMatchedTextFieldNumber = 11,
    kTitleFieldNumber = 12,
    kDescriptionFieldNumber = 13,
    kFutureproofBufferFieldNumber = 14,
    kClientUrlFieldNumber = 15,
    kLocFieldNumber = 16,
    kPollNameFieldNumber = 17,
    kMessageSecretFieldNumber = 21,
    kPollUpdateParentKeyFieldNumber = 23,
    kEncPollVoteFieldNumber = 24,
    kLngFieldNumber = 5,
    kLatFieldNumber = 7,
    kIsLiveFieldNumber = 6,
    kPaymentAmount1000FieldNumber = 8,
    kSenderTimestampMsFieldNumber = 22,
    kPollSelectableOptionsCountFieldNumber = 20,
  };
  // repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
  int polloptions_size() const;
  private:
  int _internal_polloptions_size() const;
  public:
  void clear_polloptions();
  ::proto::MsgOpaqueData_PollOption* mutable_polloptions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >*
      mutable_polloptions();
  private:
  const ::proto::MsgOpaqueData_PollOption& _internal_polloptions(int index) const;
  ::proto::MsgOpaqueData_PollOption* _internal_add_polloptions();
  public:
  const ::proto::MsgOpaqueData_PollOption& polloptions(int index) const;
  ::proto::MsgOpaqueData_PollOption* add_polloptions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >&
      polloptions() 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 string caption = 3;
  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 paymentNoteMsgBody = 9;
  bool has_paymentnotemsgbody() const;
  private:
  bool _internal_has_paymentnotemsgbody() const;
  public:
  void clear_paymentnotemsgbody();
  const std::string& paymentnotemsgbody() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args);
  std::string* mutable_paymentnotemsgbody();
  PROTOBUF_NODISCARD std::string* release_paymentnotemsgbody();
  void set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody);
  private:
  const std::string& _internal_paymentnotemsgbody() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_paymentnotemsgbody(const std::string& value);
  std::string* _internal_mutable_paymentnotemsgbody();
  public:

  // optional string canonicalUrl = 10;
  bool has_canonicalurl() const;
  private:
  bool _internal_has_canonicalurl() const;
  public:
  void clear_canonicalurl();
  const std::string& canonicalurl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_canonicalurl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_canonicalurl();
  PROTOBUF_NODISCARD std::string* release_canonicalurl();
  void set_allocated_canonicalurl(std::string* canonicalurl);
  private:
  const std::string& _internal_canonicalurl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_canonicalurl(const std::string& value);
  std::string* _internal_mutable_canonicalurl();
  public:

  // optional string matchedText = 11;
  bool has_matchedtext() const;
  private:
  bool _internal_has_matchedtext() const;
  public:
  void clear_matchedtext();
  const std::string& matchedtext() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_matchedtext(ArgT0&& arg0, ArgT... args);
  std::string* mutable_matchedtext();
  PROTOBUF_NODISCARD std::string* release_matchedtext();
  void set_allocated_matchedtext(std::string* matchedtext);
  private:
  const std::string& _internal_matchedtext() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_matchedtext(const std::string& value);
  std::string* _internal_mutable_matchedtext();
  public:

  // optional string title = 12;
  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 string description = 13;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_description(ArgT0&& arg0, ArgT... args);
  std::string* mutable_description();
  PROTOBUF_NODISCARD std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // optional bytes futureproofBuffer = 14;
  bool has_futureproofbuffer() const;
  private:
  bool _internal_has_futureproofbuffer() const;
  public:
  void clear_futureproofbuffer();
  const std::string& futureproofbuffer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_futureproofbuffer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_futureproofbuffer();
  PROTOBUF_NODISCARD std::string* release_futureproofbuffer();
  void set_allocated_futureproofbuffer(std::string* futureproofbuffer);
  private:
  const std::string& _internal_futureproofbuffer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofbuffer(const std::string& value);
  std::string* _internal_mutable_futureproofbuffer();
  public:

  // optional string clientUrl = 15;
  bool has_clienturl() const;
  private:
  bool _internal_has_clienturl() const;
  public:
  void clear_clienturl();
  const std::string& clienturl() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_clienturl(ArgT0&& arg0, ArgT... args);
  std::string* mutable_clienturl();
  PROTOBUF_NODISCARD std::string* release_clienturl();
  void set_allocated_clienturl(std::string* clienturl);
  private:
  const std::string& _internal_clienturl() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_clienturl(const std::string& value);
  std::string* _internal_mutable_clienturl();
  public:

  // optional string loc = 16;
  bool has_loc() const;
  private:
  bool _internal_has_loc() const;
  public:
  void clear_loc();
  const std::string& loc() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_loc(ArgT0&& arg0, ArgT... args);
  std::string* mutable_loc();
  PROTOBUF_NODISCARD std::string* release_loc();
  void set_allocated_loc(std::string* loc);
  private:
  const std::string& _internal_loc() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_loc(const std::string& value);
  std::string* _internal_mutable_loc();
  public:

  // optional string pollName = 17;
  bool has_pollname() const;
  private:
  bool _internal_has_pollname() const;
  public:
  void clear_pollname();
  const std::string& pollname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pollname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pollname();
  PROTOBUF_NODISCARD std::string* release_pollname();
  void set_allocated_pollname(std::string* pollname);
  private:
  const std::string& _internal_pollname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollname(const std::string& value);
  std::string* _internal_mutable_pollname();
  public:

  // optional bytes messageSecret = 21;
  bool has_messagesecret() const;
  private:
  bool _internal_has_messagesecret() const;
  public:
  void clear_messagesecret();
  const std::string& messagesecret() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_messagesecret(ArgT0&& arg0, ArgT... args);
  std::string* mutable_messagesecret();
  PROTOBUF_NODISCARD std::string* release_messagesecret();
  void set_allocated_messagesecret(std::string* messagesecret);
  private:
  const std::string& _internal_messagesecret() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
  std::string* _internal_mutable_messagesecret();
  public:

  // optional string pollUpdateParentKey = 23;
  bool has_pollupdateparentkey() const;
  private:
  bool _internal_has_pollupdateparentkey() const;
  public:
  void clear_pollupdateparentkey();
  const std::string& pollupdateparentkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pollupdateparentkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pollupdateparentkey();
  PROTOBUF_NODISCARD std::string* release_pollupdateparentkey();
  void set_allocated_pollupdateparentkey(std::string* pollupdateparentkey);
  private:
  const std::string& _internal_pollupdateparentkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pollupdateparentkey(const std::string& value);
  std::string* _internal_mutable_pollupdateparentkey();
  public:

  // optional .proto.PollEncValue encPollVote = 24;
  bool has_encpollvote() const;
  private:
  bool _internal_has_encpollvote() const;
  public:
  void clear_encpollvote();
  const ::proto::PollEncValue& encpollvote() const;
  PROTOBUF_NODISCARD ::proto::PollEncValue* release_encpollvote();
  ::proto::PollEncValue* mutable_encpollvote();
  void set_allocated_encpollvote(::proto::PollEncValue* encpollvote);
  private:
  const ::proto::PollEncValue& _internal_encpollvote() const;
  ::proto::PollEncValue* _internal_mutable_encpollvote();
  public:
  void unsafe_arena_set_allocated_encpollvote(
      ::proto::PollEncValue* encpollvote);
  ::proto::PollEncValue* unsafe_arena_release_encpollvote();

  // optional double lng = 5;
  bool has_lng() const;
  private:
  bool _internal_has_lng() const;
  public:
  void clear_lng();
  double lng() const;
  void set_lng(double value);
  private:
  double _internal_lng() const;
  void _internal_set_lng(double value);
  public:

  // optional double lat = 7;
  bool has_lat() const;
  private:
  bool _internal_has_lat() const;
  public:
  void clear_lat();
  double lat() const;
  void set_lat(double value);
  private:
  double _internal_lat() const;
  void _internal_set_lat(double value);
  public:

  // optional bool isLive = 6;
  bool has_islive() const;
  private:
  bool _internal_has_islive() const;
  public:
  void clear_islive();
  bool islive() const;
  void set_islive(bool value);
  private:
  bool _internal_islive() const;
  void _internal_set_islive(bool value);
  public:

  // optional int32 paymentAmount1000 = 8;
  bool has_paymentamount1000() const;
  private:
  bool _internal_has_paymentamount1000() const;
  public:
  void clear_paymentamount1000();
  int32_t paymentamount1000() const;
  void set_paymentamount1000(int32_t value);
  private:
  int32_t _internal_paymentamount1000() const;
  void _internal_set_paymentamount1000(int32_t value);
  public:

  // optional int64 senderTimestampMs = 22;
  bool has_sendertimestampms() const;
  private:
  bool _internal_has_sendertimestampms() const;
  public:
  void clear_sendertimestampms();
  int64_t sendertimestampms() const;
  void set_sendertimestampms(int64_t value);
  private:
  int64_t _internal_sendertimestampms() const;
  void _internal_set_sendertimestampms(int64_t value);
  public:

  // optional uint32 pollSelectableOptionsCount = 20;
  bool has_pollselectableoptionscount() const;
  private:
  bool _internal_has_pollselectableoptionscount() const;
  public:
  void clear_pollselectableoptionscount();
  uint32_t pollselectableoptionscount() const;
  void set_pollselectableoptionscount(uint32_t value);
  private:
  uint32_t _internal_pollselectableoptionscount() const;
  void _internal_set_pollselectableoptionscount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.MsgOpaqueData)
 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< ::proto::MsgOpaqueData_PollOption > polloptions_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr caption_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr paymentnotemsgbody_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonicalurl_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr matchedtext_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofbuffer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clienturl_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr loc_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pollupdateparentkey_;
    ::proto::PollEncValue* encpollvote_;
    double lng_;
    double lat_;
    bool islive_;
    int32_t paymentamount1000_;
    int64_t sendertimestampms_;
    uint32_t pollselectableoptionscount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class MsgRowOpaqueData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.MsgRowOpaqueData) */ {
 public:
  inline MsgRowOpaqueData() : MsgRowOpaqueData(nullptr) {}
  ~MsgRowOpaqueData() override;
  explicit PROTOBUF_CONSTEXPR MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MsgRowOpaqueData(const MsgRowOpaqueData& from);
  MsgRowOpaqueData(MsgRowOpaqueData&& from) noexcept
    : MsgRowOpaqueData() {
    *this = ::std::move(from);
  }

  inline MsgRowOpaqueData& operator=(const MsgRowOpaqueData& from) {
    CopyFrom(from);
    return *this;
  }
  inline MsgRowOpaqueData& operator=(MsgRowOpaqueData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const MsgRowOpaqueData& default_instance() {
    return *internal_default_instance();
  }
  static inline const MsgRowOpaqueData* internal_default_instance() {
    return reinterpret_cast<const MsgRowOpaqueData*>(
               &_MsgRowOpaqueData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    143;

  friend void swap(MsgRowOpaqueData& a, MsgRowOpaqueData& b) {
    a.Swap(&b);
  }
  inline void Swap(MsgRowOpaqueData* 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(MsgRowOpaqueData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MsgRowOpaqueData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MsgRowOpaqueData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const MsgRowOpaqueData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const MsgRowOpaqueData& from) {
    MsgRowOpaqueData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MsgRowOpaqueData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.MsgRowOpaqueData";
  }
  protected:
  explicit MsgRowOpaqueData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCurrentMsgFieldNumber = 1,
    kQuotedMsgFieldNumber = 2,
  };
  // optional .proto.MsgOpaqueData currentMsg = 1;
  bool has_currentmsg() const;
  private:
  bool _internal_has_currentmsg() const;
  public:
  void clear_currentmsg();
  const ::proto::MsgOpaqueData& currentmsg() const;
  PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_currentmsg();
  ::proto::MsgOpaqueData* mutable_currentmsg();
  void set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg);
  private:
  const ::proto::MsgOpaqueData& _internal_currentmsg() const;
  ::proto::MsgOpaqueData* _internal_mutable_currentmsg();
  public:
  void unsafe_arena_set_allocated_currentmsg(
      ::proto::MsgOpaqueData* currentmsg);
  ::proto::MsgOpaqueData* unsafe_arena_release_currentmsg();

  // optional .proto.MsgOpaqueData quotedMsg = 2;
  bool has_quotedmsg() const;
  private:
  bool _internal_has_quotedmsg() const;
  public:
  void clear_quotedmsg();
  const ::proto::MsgOpaqueData& quotedmsg() const;
  PROTOBUF_NODISCARD ::proto::MsgOpaqueData* release_quotedmsg();
  ::proto::MsgOpaqueData* mutable_quotedmsg();
  void set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg);
  private:
  const ::proto::MsgOpaqueData& _internal_quotedmsg() const;
  ::proto::MsgOpaqueData* _internal_mutable_quotedmsg();
  public:
  void unsafe_arena_set_allocated_quotedmsg(
      ::proto::MsgOpaqueData* quotedmsg);
  ::proto::MsgOpaqueData* unsafe_arena_release_quotedmsg();

  // @@protoc_insertion_point(class_scope:proto.MsgRowOpaqueData)
 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_;
    ::proto::MsgOpaqueData* currentmsg_;
    ::proto::MsgOpaqueData* quotedmsg_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class NoiseCertificate_Details final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate.Details) */ {
 public:
  inline NoiseCertificate_Details() : NoiseCertificate_Details(nullptr) {}
  ~NoiseCertificate_Details() override;
  explicit PROTOBUF_CONSTEXPR NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NoiseCertificate_Details(const NoiseCertificate_Details& from);
  NoiseCertificate_Details(NoiseCertificate_Details&& from) noexcept
    : NoiseCertificate_Details() {
    *this = ::std::move(from);
  }

  inline NoiseCertificate_Details& operator=(const NoiseCertificate_Details& from) {
    CopyFrom(from);
    return *this;
  }
  inline NoiseCertificate_Details& operator=(NoiseCertificate_Details&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NoiseCertificate_Details& default_instance() {
    return *internal_default_instance();
  }
  static inline const NoiseCertificate_Details* internal_default_instance() {
    return reinterpret_cast<const NoiseCertificate_Details*>(
               &_NoiseCertificate_Details_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    144;

  friend void swap(NoiseCertificate_Details& a, NoiseCertificate_Details& b) {
    a.Swap(&b);
  }
  inline void Swap(NoiseCertificate_Details* 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(NoiseCertificate_Details* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NoiseCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NoiseCertificate_Details>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NoiseCertificate_Details& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NoiseCertificate_Details& from) {
    NoiseCertificate_Details::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NoiseCertificate_Details* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.NoiseCertificate.Details";
  }
  protected:
  explicit NoiseCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIssuerFieldNumber = 2,
    kSubjectFieldNumber = 4,
    kKeyFieldNumber = 5,
    kExpiresFieldNumber = 3,
    kSerialFieldNumber = 1,
  };
  // optional string issuer = 2;
  bool has_issuer() const;
  private:
  bool _internal_has_issuer() const;
  public:
  void clear_issuer();
  const std::string& issuer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_issuer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_issuer();
  PROTOBUF_NODISCARD std::string* release_issuer();
  void set_allocated_issuer(std::string* issuer);
  private:
  const std::string& _internal_issuer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value);
  std::string* _internal_mutable_issuer();
  public:

  // optional string subject = 4;
  bool has_subject() const;
  private:
  bool _internal_has_subject() const;
  public:
  void clear_subject();
  const std::string& subject() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_subject(ArgT0&& arg0, ArgT... args);
  std::string* mutable_subject();
  PROTOBUF_NODISCARD std::string* release_subject();
  void set_allocated_subject(std::string* subject);
  private:
  const std::string& _internal_subject() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_subject(const std::string& value);
  std::string* _internal_mutable_subject();
  public:

  // optional bytes key = 5;
  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 uint64 expires = 3;
  bool has_expires() const;
  private:
  bool _internal_has_expires() const;
  public:
  void clear_expires();
  uint64_t expires() const;
  void set_expires(uint64_t value);
  private:
  uint64_t _internal_expires() const;
  void _internal_set_expires(uint64_t value);
  public:

  // optional uint32 serial = 1;
  bool has_serial() const;
  private:
  bool _internal_has_serial() const;
  public:
  void clear_serial();
  uint32_t serial() const;
  void set_serial(uint32_t value);
  private:
  uint32_t _internal_serial() const;
  void _internal_set_serial(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.NoiseCertificate.Details)
 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 issuer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr subject_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
    uint64_t expires_;
    uint32_t serial_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class NoiseCertificate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NoiseCertificate) */ {
 public:
  inline NoiseCertificate() : NoiseCertificate(nullptr) {}
  ~NoiseCertificate() override;
  explicit PROTOBUF_CONSTEXPR NoiseCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NoiseCertificate(const NoiseCertificate& from);
  NoiseCertificate(NoiseCertificate&& from) noexcept
    : NoiseCertificate() {
    *this = ::std::move(from);
  }

  inline NoiseCertificate& operator=(const NoiseCertificate& from) {
    CopyFrom(from);
    return *this;
  }
  inline NoiseCertificate& operator=(NoiseCertificate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NoiseCertificate& default_instance() {
    return *internal_default_instance();
  }
  static inline const NoiseCertificate* internal_default_instance() {
    return reinterpret_cast<const NoiseCertificate*>(
               &_NoiseCertificate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    145;

  friend void swap(NoiseCertificate& a, NoiseCertificate& b) {
    a.Swap(&b);
  }
  inline void Swap(NoiseCertificate* 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(NoiseCertificate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NoiseCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NoiseCertificate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NoiseCertificate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NoiseCertificate& from) {
    NoiseCertificate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NoiseCertificate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.NoiseCertificate";
  }
  protected:
  explicit NoiseCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef NoiseCertificate_Details Details;

  // accessors -------------------------------------------------------

  enum : int {
    kDetailsFieldNumber = 1,
    kSignatureFieldNumber = 2,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_NODISCARD std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // @@protoc_insertion_point(class_scope:proto.NoiseCertificate)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class NotificationMessageInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.NotificationMessageInfo) */ {
 public:
  inline NotificationMessageInfo() : NotificationMessageInfo(nullptr) {}
  ~NotificationMessageInfo() override;
  explicit PROTOBUF_CONSTEXPR NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NotificationMessageInfo(const NotificationMessageInfo& from);
  NotificationMessageInfo(NotificationMessageInfo&& from) noexcept
    : NotificationMessageInfo() {
    *this = ::std::move(from);
  }

  inline NotificationMessageInfo& operator=(const NotificationMessageInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline NotificationMessageInfo& operator=(NotificationMessageInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NotificationMessageInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const NotificationMessageInfo* internal_default_instance() {
    return reinterpret_cast<const NotificationMessageInfo*>(
               &_NotificationMessageInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    146;

  friend void swap(NotificationMessageInfo& a, NotificationMessageInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(NotificationMessageInfo* 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(NotificationMessageInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  NotificationMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NotificationMessageInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NotificationMessageInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const NotificationMessageInfo& from) {
    NotificationMessageInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NotificationMessageInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.NotificationMessageInfo";
  }
  protected:
  explicit NotificationMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kParticipantFieldNumber = 4,
    kKeyFieldNumber = 1,
    kMessageFieldNumber = 2,
    kMessageTimestampFieldNumber = 3,
  };
  // optional string participant = 4;
  bool has_participant() const;
  private:
  bool _internal_has_participant() const;
  public:
  void clear_participant();
  const std::string& participant() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_participant(ArgT0&& arg0, ArgT... args);
  std::string* mutable_participant();
  PROTOBUF_NODISCARD std::string* release_participant();
  void set_allocated_participant(std::string* participant);
  private:
  const std::string& _internal_participant() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
  std::string* _internal_mutable_participant();
  public:

  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional .proto.Message message = 2;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const ::proto::Message& message() const;
  PROTOBUF_NODISCARD ::proto::Message* release_message();
  ::proto::Message* mutable_message();
  void set_allocated_message(::proto::Message* message);
  private:
  const ::proto::Message& _internal_message() const;
  ::proto::Message* _internal_mutable_message();
  public:
  void unsafe_arena_set_allocated_message(
      ::proto::Message* message);
  ::proto::Message* unsafe_arena_release_message();

  // optional uint64 messageTimestamp = 3;
  bool has_messagetimestamp() const;
  private:
  bool _internal_has_messagetimestamp() const;
  public:
  void clear_messagetimestamp();
  uint64_t messagetimestamp() const;
  void set_messagetimestamp(uint64_t value);
  private:
  uint64_t _internal_messagetimestamp() const;
  void _internal_set_messagetimestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.NotificationMessageInfo)
 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 participant_;
    ::proto::MessageKey* key_;
    ::proto::Message* message_;
    uint64_t messagetimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PastParticipant final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipant) */ {
 public:
  inline PastParticipant() : PastParticipant(nullptr) {}
  ~PastParticipant() override;
  explicit PROTOBUF_CONSTEXPR PastParticipant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PastParticipant(const PastParticipant& from);
  PastParticipant(PastParticipant&& from) noexcept
    : PastParticipant() {
    *this = ::std::move(from);
  }

  inline PastParticipant& operator=(const PastParticipant& from) {
    CopyFrom(from);
    return *this;
  }
  inline PastParticipant& operator=(PastParticipant&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PastParticipant& default_instance() {
    return *internal_default_instance();
  }
  static inline const PastParticipant* internal_default_instance() {
    return reinterpret_cast<const PastParticipant*>(
               &_PastParticipant_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    147;

  friend void swap(PastParticipant& a, PastParticipant& b) {
    a.Swap(&b);
  }
  inline void Swap(PastParticipant* 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(PastParticipant* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PastParticipant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PastParticipant>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PastParticipant& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PastParticipant& from) {
    PastParticipant::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PastParticipant* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PastParticipant";
  }
  protected:
  explicit PastParticipant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef PastParticipant_LeaveReason LeaveReason;
  static constexpr LeaveReason LEFT =
    PastParticipant_LeaveReason_LEFT;
  static constexpr LeaveReason REMOVED =
    PastParticipant_LeaveReason_REMOVED;
  static inline bool LeaveReason_IsValid(int value) {
    return PastParticipant_LeaveReason_IsValid(value);
  }
  static constexpr LeaveReason LeaveReason_MIN =
    PastParticipant_LeaveReason_LeaveReason_MIN;
  static constexpr LeaveReason LeaveReason_MAX =
    PastParticipant_LeaveReason_LeaveReason_MAX;
  static constexpr int LeaveReason_ARRAYSIZE =
    PastParticipant_LeaveReason_LeaveReason_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  LeaveReason_descriptor() {
    return PastParticipant_LeaveReason_descriptor();
  }
  template<typename T>
  static inline const std::string& LeaveReason_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LeaveReason>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LeaveReason_Name.");
    return PastParticipant_LeaveReason_Name(enum_t_value);
  }
  static inline bool LeaveReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      LeaveReason* value) {
    return PastParticipant_LeaveReason_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kUserJidFieldNumber = 1,
    kLeaveTsFieldNumber = 3,
    kLeaveReasonFieldNumber = 2,
  };
  // required string userJid = 1;
  bool has_userjid() const;
  private:
  bool _internal_has_userjid() const;
  public:
  void clear_userjid();
  const std::string& userjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_userjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_userjid();
  PROTOBUF_NODISCARD std::string* release_userjid();
  void set_allocated_userjid(std::string* userjid);
  private:
  const std::string& _internal_userjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
  std::string* _internal_mutable_userjid();
  public:

  // required uint64 leaveTs = 3;
  bool has_leavets() const;
  private:
  bool _internal_has_leavets() const;
  public:
  void clear_leavets();
  uint64_t leavets() const;
  void set_leavets(uint64_t value);
  private:
  uint64_t _internal_leavets() const;
  void _internal_set_leavets(uint64_t value);
  public:

  // required .proto.PastParticipant.LeaveReason leaveReason = 2;
  bool has_leavereason() const;
  private:
  bool _internal_has_leavereason() const;
  public:
  void clear_leavereason();
  ::proto::PastParticipant_LeaveReason leavereason() const;
  void set_leavereason(::proto::PastParticipant_LeaveReason value);
  private:
  ::proto::PastParticipant_LeaveReason _internal_leavereason() const;
  void _internal_set_leavereason(::proto::PastParticipant_LeaveReason value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PastParticipant)
 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 userjid_;
    uint64_t leavets_;
    int leavereason_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PastParticipants final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PastParticipants) */ {
 public:
  inline PastParticipants() : PastParticipants(nullptr) {}
  ~PastParticipants() override;
  explicit PROTOBUF_CONSTEXPR PastParticipants(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PastParticipants(const PastParticipants& from);
  PastParticipants(PastParticipants&& from) noexcept
    : PastParticipants() {
    *this = ::std::move(from);
  }

  inline PastParticipants& operator=(const PastParticipants& from) {
    CopyFrom(from);
    return *this;
  }
  inline PastParticipants& operator=(PastParticipants&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PastParticipants& default_instance() {
    return *internal_default_instance();
  }
  static inline const PastParticipants* internal_default_instance() {
    return reinterpret_cast<const PastParticipants*>(
               &_PastParticipants_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    148;

  friend void swap(PastParticipants& a, PastParticipants& b) {
    a.Swap(&b);
  }
  inline void Swap(PastParticipants* 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(PastParticipants* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PastParticipants* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PastParticipants>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PastParticipants& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PastParticipants& from) {
    PastParticipants::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PastParticipants* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PastParticipants";
  }
  protected:
  explicit PastParticipants(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPastParticipantsFieldNumber = 2,
    kGroupJidFieldNumber = 1,
  };
  // repeated .proto.PastParticipant pastParticipants = 2;
  int pastparticipants_size() const;
  private:
  int _internal_pastparticipants_size() const;
  public:
  void clear_pastparticipants();
  ::proto::PastParticipant* mutable_pastparticipants(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >*
      mutable_pastparticipants();
  private:
  const ::proto::PastParticipant& _internal_pastparticipants(int index) const;
  ::proto::PastParticipant* _internal_add_pastparticipants();
  public:
  const ::proto::PastParticipant& pastparticipants(int index) const;
  ::proto::PastParticipant* add_pastparticipants();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >&
      pastparticipants() const;

  // required string groupJid = 1;
  bool has_groupjid() const;
  private:
  bool _internal_has_groupjid() const;
  public:
  void clear_groupjid();
  const std::string& groupjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupjid();
  PROTOBUF_NODISCARD std::string* release_groupjid();
  void set_allocated_groupjid(std::string* groupjid);
  private:
  const std::string& _internal_groupjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupjid(const std::string& value);
  std::string* _internal_mutable_groupjid();
  public:

  // @@protoc_insertion_point(class_scope:proto.PastParticipants)
 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< ::proto::PastParticipant > pastparticipants_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupjid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PaymentBackground_MediaData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground.MediaData) */ {
 public:
  inline PaymentBackground_MediaData() : PaymentBackground_MediaData(nullptr) {}
  ~PaymentBackground_MediaData() override;
  explicit PROTOBUF_CONSTEXPR PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PaymentBackground_MediaData(const PaymentBackground_MediaData& from);
  PaymentBackground_MediaData(PaymentBackground_MediaData&& from) noexcept
    : PaymentBackground_MediaData() {
    *this = ::std::move(from);
  }

  inline PaymentBackground_MediaData& operator=(const PaymentBackground_MediaData& from) {
    CopyFrom(from);
    return *this;
  }
  inline PaymentBackground_MediaData& operator=(PaymentBackground_MediaData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PaymentBackground_MediaData& default_instance() {
    return *internal_default_instance();
  }
  static inline const PaymentBackground_MediaData* internal_default_instance() {
    return reinterpret_cast<const PaymentBackground_MediaData*>(
               &_PaymentBackground_MediaData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    149;

  friend void swap(PaymentBackground_MediaData& a, PaymentBackground_MediaData& b) {
    a.Swap(&b);
  }
  inline void Swap(PaymentBackground_MediaData* 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(PaymentBackground_MediaData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PaymentBackground_MediaData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PaymentBackground_MediaData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PaymentBackground_MediaData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PaymentBackground_MediaData& from) {
    PaymentBackground_MediaData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PaymentBackground_MediaData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PaymentBackground.MediaData";
  }
  protected:
  explicit PaymentBackground_MediaData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMediaKeyFieldNumber = 1,
    kFileSha256FieldNumber = 3,
    kFileEncSha256FieldNumber = 4,
    kDirectPathFieldNumber = 5,
    kMediaKeyTimestampFieldNumber = 2,
  };
  // optional bytes mediaKey = 1;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional bytes fileSha256 = 3;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes fileEncSha256 = 4;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional string directPath = 5;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional int64 mediaKeyTimestamp = 2;
  bool has_mediakeytimestamp() const;
  private:
  bool _internal_has_mediakeytimestamp() const;
  public:
  void clear_mediakeytimestamp();
  int64_t mediakeytimestamp() const;
  void set_mediakeytimestamp(int64_t value);
  private:
  int64_t _internal_mediakeytimestamp() const;
  void _internal_set_mediakeytimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PaymentBackground.MediaData)
 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 mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    int64_t mediakeytimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PaymentBackground final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentBackground) */ {
 public:
  inline PaymentBackground() : PaymentBackground(nullptr) {}
  ~PaymentBackground() override;
  explicit PROTOBUF_CONSTEXPR PaymentBackground(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PaymentBackground(const PaymentBackground& from);
  PaymentBackground(PaymentBackground&& from) noexcept
    : PaymentBackground() {
    *this = ::std::move(from);
  }

  inline PaymentBackground& operator=(const PaymentBackground& from) {
    CopyFrom(from);
    return *this;
  }
  inline PaymentBackground& operator=(PaymentBackground&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PaymentBackground& default_instance() {
    return *internal_default_instance();
  }
  static inline const PaymentBackground* internal_default_instance() {
    return reinterpret_cast<const PaymentBackground*>(
               &_PaymentBackground_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    150;

  friend void swap(PaymentBackground& a, PaymentBackground& b) {
    a.Swap(&b);
  }
  inline void Swap(PaymentBackground* 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(PaymentBackground* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PaymentBackground* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PaymentBackground>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PaymentBackground& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PaymentBackground& from) {
    PaymentBackground::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PaymentBackground* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PaymentBackground";
  }
  protected:
  explicit PaymentBackground(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef PaymentBackground_MediaData MediaData;

  typedef PaymentBackground_Type Type;
  static constexpr Type UNKNOWN =
    PaymentBackground_Type_UNKNOWN;
  static constexpr Type DEFAULT =
    PaymentBackground_Type_DEFAULT;
  static inline bool Type_IsValid(int value) {
    return PaymentBackground_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    PaymentBackground_Type_Type_MIN;
  static constexpr Type Type_MAX =
    PaymentBackground_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    PaymentBackground_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return PaymentBackground_Type_descriptor();
  }
  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 PaymentBackground_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Type* value) {
    return PaymentBackground_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 1,
    kMimetypeFieldNumber = 5,
    kMediaDataFieldNumber = 9,
    kFileLengthFieldNumber = 2,
    kWidthFieldNumber = 3,
    kHeightFieldNumber = 4,
    kPlaceholderArgbFieldNumber = 6,
    kTextArgbFieldNumber = 7,
    kSubtextArgbFieldNumber = 8,
    kTypeFieldNumber = 10,
  };
  // optional string id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional string mimetype = 5;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional .proto.PaymentBackground.MediaData mediaData = 9;
  bool has_mediadata() const;
  private:
  bool _internal_has_mediadata() const;
  public:
  void clear_mediadata();
  const ::proto::PaymentBackground_MediaData& mediadata() const;
  PROTOBUF_NODISCARD ::proto::PaymentBackground_MediaData* release_mediadata();
  ::proto::PaymentBackground_MediaData* mutable_mediadata();
  void set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata);
  private:
  const ::proto::PaymentBackground_MediaData& _internal_mediadata() const;
  ::proto::PaymentBackground_MediaData* _internal_mutable_mediadata();
  public:
  void unsafe_arena_set_allocated_mediadata(
      ::proto::PaymentBackground_MediaData* mediadata);
  ::proto::PaymentBackground_MediaData* unsafe_arena_release_mediadata();

  // optional uint64 fileLength = 2;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional uint32 width = 3;
  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 = 4;
  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:

  // optional fixed32 placeholderArgb = 6;
  bool has_placeholderargb() const;
  private:
  bool _internal_has_placeholderargb() const;
  public:
  void clear_placeholderargb();
  uint32_t placeholderargb() const;
  void set_placeholderargb(uint32_t value);
  private:
  uint32_t _internal_placeholderargb() const;
  void _internal_set_placeholderargb(uint32_t value);
  public:

  // optional fixed32 textArgb = 7;
  bool has_textargb() const;
  private:
  bool _internal_has_textargb() const;
  public:
  void clear_textargb();
  uint32_t textargb() const;
  void set_textargb(uint32_t value);
  private:
  uint32_t _internal_textargb() const;
  void _internal_set_textargb(uint32_t value);
  public:

  // optional fixed32 subtextArgb = 8;
  bool has_subtextargb() const;
  private:
  bool _internal_has_subtextargb() const;
  public:
  void clear_subtextargb();
  uint32_t subtextargb() const;
  void set_subtextargb(uint32_t value);
  private:
  uint32_t _internal_subtextargb() const;
  void _internal_set_subtextargb(uint32_t value);
  public:

  // optional .proto.PaymentBackground.Type type = 10;
  bool has_type() const;
  private:
  bool _internal_has_type() const;
  public:
  void clear_type();
  ::proto::PaymentBackground_Type type() const;
  void set_type(::proto::PaymentBackground_Type value);
  private:
  ::proto::PaymentBackground_Type _internal_type() const;
  void _internal_set_type(::proto::PaymentBackground_Type value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PaymentBackground)
 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 id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::proto::PaymentBackground_MediaData* mediadata_;
    uint64_t filelength_;
    uint32_t width_;
    uint32_t height_;
    uint32_t placeholderargb_;
    uint32_t textargb_;
    uint32_t subtextargb_;
    int type_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PaymentInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PaymentInfo) */ {
 public:
  inline PaymentInfo() : PaymentInfo(nullptr) {}
  ~PaymentInfo() override;
  explicit PROTOBUF_CONSTEXPR PaymentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PaymentInfo(const PaymentInfo& from);
  PaymentInfo(PaymentInfo&& from) noexcept
    : PaymentInfo() {
    *this = ::std::move(from);
  }

  inline PaymentInfo& operator=(const PaymentInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline PaymentInfo& operator=(PaymentInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PaymentInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const PaymentInfo* internal_default_instance() {
    return reinterpret_cast<const PaymentInfo*>(
               &_PaymentInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    151;

  friend void swap(PaymentInfo& a, PaymentInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(PaymentInfo* 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(PaymentInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PaymentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PaymentInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PaymentInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PaymentInfo& from) {
    PaymentInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PaymentInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PaymentInfo";
  }
  protected:
  explicit PaymentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef PaymentInfo_Currency Currency;
  static constexpr Currency UNKNOWN_CURRENCY =
    PaymentInfo_Currency_UNKNOWN_CURRENCY;
  static constexpr Currency INR =
    PaymentInfo_Currency_INR;
  static inline bool Currency_IsValid(int value) {
    return PaymentInfo_Currency_IsValid(value);
  }
  static constexpr Currency Currency_MIN =
    PaymentInfo_Currency_Currency_MIN;
  static constexpr Currency Currency_MAX =
    PaymentInfo_Currency_Currency_MAX;
  static constexpr int Currency_ARRAYSIZE =
    PaymentInfo_Currency_Currency_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Currency_descriptor() {
    return PaymentInfo_Currency_descriptor();
  }
  template<typename T>
  static inline const std::string& Currency_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Currency>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Currency_Name.");
    return PaymentInfo_Currency_Name(enum_t_value);
  }
  static inline bool Currency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Currency* value) {
    return PaymentInfo_Currency_Parse(name, value);
  }

  typedef PaymentInfo_Status Status;
  static constexpr Status UNKNOWN_STATUS =
    PaymentInfo_Status_UNKNOWN_STATUS;
  static constexpr Status PROCESSING =
    PaymentInfo_Status_PROCESSING;
  static constexpr Status SENT =
    PaymentInfo_Status_SENT;
  static constexpr Status NEED_TO_ACCEPT =
    PaymentInfo_Status_NEED_TO_ACCEPT;
  static constexpr Status COMPLETE =
    PaymentInfo_Status_COMPLETE;
  static constexpr Status COULD_NOT_COMPLETE =
    PaymentInfo_Status_COULD_NOT_COMPLETE;
  static constexpr Status REFUNDED =
    PaymentInfo_Status_REFUNDED;
  static constexpr Status EXPIRED =
    PaymentInfo_Status_EXPIRED;
  static constexpr Status REJECTED =
    PaymentInfo_Status_REJECTED;
  static constexpr Status CANCELLED =
    PaymentInfo_Status_CANCELLED;
  static constexpr Status WAITING_FOR_PAYER =
    PaymentInfo_Status_WAITING_FOR_PAYER;
  static constexpr Status WAITING =
    PaymentInfo_Status_WAITING;
  static inline bool Status_IsValid(int value) {
    return PaymentInfo_Status_IsValid(value);
  }
  static constexpr Status Status_MIN =
    PaymentInfo_Status_Status_MIN;
  static constexpr Status Status_MAX =
    PaymentInfo_Status_Status_MAX;
  static constexpr int Status_ARRAYSIZE =
    PaymentInfo_Status_Status_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Status_descriptor() {
    return PaymentInfo_Status_descriptor();
  }
  template<typename T>
  static inline const std::string& Status_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Status>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Status_Name.");
    return PaymentInfo_Status_Name(enum_t_value);
  }
  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Status* value) {
    return PaymentInfo_Status_Parse(name, value);
  }

  typedef PaymentInfo_TxnStatus TxnStatus;
  static constexpr TxnStatus UNKNOWN =
    PaymentInfo_TxnStatus_UNKNOWN;
  static constexpr TxnStatus PENDING_SETUP =
    PaymentInfo_TxnStatus_PENDING_SETUP;
  static constexpr TxnStatus PENDING_RECEIVER_SETUP =
    PaymentInfo_TxnStatus_PENDING_RECEIVER_SETUP;
  static constexpr TxnStatus INIT =
    PaymentInfo_TxnStatus_INIT;
  static constexpr TxnStatus SUCCESS =
    PaymentInfo_TxnStatus_SUCCESS;
  static constexpr TxnStatus COMPLETED =
    PaymentInfo_TxnStatus_COMPLETED;
  static constexpr TxnStatus FAILED =
    PaymentInfo_TxnStatus_FAILED;
  static constexpr TxnStatus FAILED_RISK =
    PaymentInfo_TxnStatus_FAILED_RISK;
  static constexpr TxnStatus FAILED_PROCESSING =
    PaymentInfo_TxnStatus_FAILED_PROCESSING;
  static constexpr TxnStatus FAILED_RECEIVER_PROCESSING =
    PaymentInfo_TxnStatus_FAILED_RECEIVER_PROCESSING;
  static constexpr TxnStatus FAILED_DA =
    PaymentInfo_TxnStatus_FAILED_DA;
  static constexpr TxnStatus FAILED_DA_FINAL =
    PaymentInfo_TxnStatus_FAILED_DA_FINAL;
  static constexpr TxnStatus REFUNDED_TXN =
    PaymentInfo_TxnStatus_REFUNDED_TXN;
  static constexpr TxnStatus REFUND_FAILED =
    PaymentInfo_TxnStatus_REFUND_FAILED;
  static constexpr TxnStatus REFUND_FAILED_PROCESSING =
    PaymentInfo_TxnStatus_REFUND_FAILED_PROCESSING;
  static constexpr TxnStatus REFUND_FAILED_DA =
    PaymentInfo_TxnStatus_REFUND_FAILED_DA;
  static constexpr TxnStatus EXPIRED_TXN =
    PaymentInfo_TxnStatus_EXPIRED_TXN;
  static constexpr TxnStatus AUTH_CANCELED =
    PaymentInfo_TxnStatus_AUTH_CANCELED;
  static constexpr TxnStatus AUTH_CANCEL_FAILED_PROCESSING =
    PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED_PROCESSING;
  static constexpr TxnStatus AUTH_CANCEL_FAILED =
    PaymentInfo_TxnStatus_AUTH_CANCEL_FAILED;
  static constexpr TxnStatus COLLECT_INIT =
    PaymentInfo_TxnStatus_COLLECT_INIT;
  static constexpr TxnStatus COLLECT_SUCCESS =
    PaymentInfo_TxnStatus_COLLECT_SUCCESS;
  static constexpr TxnStatus COLLECT_FAILED =
    PaymentInfo_TxnStatus_COLLECT_FAILED;
  static constexpr TxnStatus COLLECT_FAILED_RISK =
    PaymentInfo_TxnStatus_COLLECT_FAILED_RISK;
  static constexpr TxnStatus COLLECT_REJECTED =
    PaymentInfo_TxnStatus_COLLECT_REJECTED;
  static constexpr TxnStatus COLLECT_EXPIRED =
    PaymentInfo_TxnStatus_COLLECT_EXPIRED;
  static constexpr TxnStatus COLLECT_CANCELED =
    PaymentInfo_TxnStatus_COLLECT_CANCELED;
  static constexpr TxnStatus COLLECT_CANCELLING =
    PaymentInfo_TxnStatus_COLLECT_CANCELLING;
  static constexpr TxnStatus IN_REVIEW =
    PaymentInfo_TxnStatus_IN_REVIEW;
  static constexpr TxnStatus REVERSAL_SUCCESS =
    PaymentInfo_TxnStatus_REVERSAL_SUCCESS;
  static constexpr TxnStatus REVERSAL_PENDING =
    PaymentInfo_TxnStatus_REVERSAL_PENDING;
  static constexpr TxnStatus REFUND_PENDING =
    PaymentInfo_TxnStatus_REFUND_PENDING;
  static inline bool TxnStatus_IsValid(int value) {
    return PaymentInfo_TxnStatus_IsValid(value);
  }
  static constexpr TxnStatus TxnStatus_MIN =
    PaymentInfo_TxnStatus_TxnStatus_MIN;
  static constexpr TxnStatus TxnStatus_MAX =
    PaymentInfo_TxnStatus_TxnStatus_MAX;
  static constexpr int TxnStatus_ARRAYSIZE =
    PaymentInfo_TxnStatus_TxnStatus_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  TxnStatus_descriptor() {
    return PaymentInfo_TxnStatus_descriptor();
  }
  template<typename T>
  static inline const std::string& TxnStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TxnStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TxnStatus_Name.");
    return PaymentInfo_TxnStatus_Name(enum_t_value);
  }
  static inline bool TxnStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      TxnStatus* value) {
    return PaymentInfo_TxnStatus_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kReceiverJidFieldNumber = 3,
    kCurrencyFieldNumber = 9,
    kRequestMessageKeyFieldNumber = 6,
    kPrimaryAmountFieldNumber = 12,
    kExchangeAmountFieldNumber = 13,
    kAmount1000FieldNumber = 2,
    kCurrencyDeprecatedFieldNumber = 1,
    kStatusFieldNumber = 4,
    kTransactionTimestampFieldNumber = 5,
    kExpiryTimestampFieldNumber = 7,
    kFutureproofedFieldNumber = 8,
    kUseNoviFiatFormatFieldNumber = 11,
    kTxnStatusFieldNumber = 10,
  };
  // optional string receiverJid = 3;
  bool has_receiverjid() const;
  private:
  bool _internal_has_receiverjid() const;
  public:
  void clear_receiverjid();
  const std::string& receiverjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_receiverjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_receiverjid();
  PROTOBUF_NODISCARD std::string* release_receiverjid();
  void set_allocated_receiverjid(std::string* receiverjid);
  private:
  const std::string& _internal_receiverjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_receiverjid(const std::string& value);
  std::string* _internal_mutable_receiverjid();
  public:

  // optional string currency = 9;
  bool has_currency() const;
  private:
  bool _internal_has_currency() const;
  public:
  void clear_currency();
  const std::string& currency() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_currency(ArgT0&& arg0, ArgT... args);
  std::string* mutable_currency();
  PROTOBUF_NODISCARD std::string* release_currency();
  void set_allocated_currency(std::string* currency);
  private:
  const std::string& _internal_currency() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_currency(const std::string& value);
  std::string* _internal_mutable_currency();
  public:

  // optional .proto.MessageKey requestMessageKey = 6;
  bool has_requestmessagekey() const;
  private:
  bool _internal_has_requestmessagekey() const;
  public:
  void clear_requestmessagekey();
  const ::proto::MessageKey& requestmessagekey() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_requestmessagekey();
  ::proto::MessageKey* mutable_requestmessagekey();
  void set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey);
  private:
  const ::proto::MessageKey& _internal_requestmessagekey() const;
  ::proto::MessageKey* _internal_mutable_requestmessagekey();
  public:
  void unsafe_arena_set_allocated_requestmessagekey(
      ::proto::MessageKey* requestmessagekey);
  ::proto::MessageKey* unsafe_arena_release_requestmessagekey();

  // optional .proto.Money primaryAmount = 12;
  bool has_primaryamount() const;
  private:
  bool _internal_has_primaryamount() const;
  public:
  void clear_primaryamount();
  const ::proto::Money& primaryamount() const;
  PROTOBUF_NODISCARD ::proto::Money* release_primaryamount();
  ::proto::Money* mutable_primaryamount();
  void set_allocated_primaryamount(::proto::Money* primaryamount);
  private:
  const ::proto::Money& _internal_primaryamount() const;
  ::proto::Money* _internal_mutable_primaryamount();
  public:
  void unsafe_arena_set_allocated_primaryamount(
      ::proto::Money* primaryamount);
  ::proto::Money* unsafe_arena_release_primaryamount();

  // optional .proto.Money exchangeAmount = 13;
  bool has_exchangeamount() const;
  private:
  bool _internal_has_exchangeamount() const;
  public:
  void clear_exchangeamount();
  const ::proto::Money& exchangeamount() const;
  PROTOBUF_NODISCARD ::proto::Money* release_exchangeamount();
  ::proto::Money* mutable_exchangeamount();
  void set_allocated_exchangeamount(::proto::Money* exchangeamount);
  private:
  const ::proto::Money& _internal_exchangeamount() const;
  ::proto::Money* _internal_mutable_exchangeamount();
  public:
  void unsafe_arena_set_allocated_exchangeamount(
      ::proto::Money* exchangeamount);
  ::proto::Money* unsafe_arena_release_exchangeamount();

  // optional uint64 amount1000 = 2;
  bool has_amount1000() const;
  private:
  bool _internal_has_amount1000() const;
  public:
  void clear_amount1000();
  uint64_t amount1000() const;
  void set_amount1000(uint64_t value);
  private:
  uint64_t _internal_amount1000() const;
  void _internal_set_amount1000(uint64_t value);
  public:

  // optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
  bool has_currencydeprecated() const;
  private:
  bool _internal_has_currencydeprecated() const;
  public:
  void clear_currencydeprecated();
  ::proto::PaymentInfo_Currency currencydeprecated() const;
  void set_currencydeprecated(::proto::PaymentInfo_Currency value);
  private:
  ::proto::PaymentInfo_Currency _internal_currencydeprecated() const;
  void _internal_set_currencydeprecated(::proto::PaymentInfo_Currency value);
  public:

  // optional .proto.PaymentInfo.Status status = 4;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::proto::PaymentInfo_Status status() const;
  void set_status(::proto::PaymentInfo_Status value);
  private:
  ::proto::PaymentInfo_Status _internal_status() const;
  void _internal_set_status(::proto::PaymentInfo_Status value);
  public:

  // optional uint64 transactionTimestamp = 5;
  bool has_transactiontimestamp() const;
  private:
  bool _internal_has_transactiontimestamp() const;
  public:
  void clear_transactiontimestamp();
  uint64_t transactiontimestamp() const;
  void set_transactiontimestamp(uint64_t value);
  private:
  uint64_t _internal_transactiontimestamp() const;
  void _internal_set_transactiontimestamp(uint64_t value);
  public:

  // optional uint64 expiryTimestamp = 7;
  bool has_expirytimestamp() const;
  private:
  bool _internal_has_expirytimestamp() const;
  public:
  void clear_expirytimestamp();
  uint64_t expirytimestamp() const;
  void set_expirytimestamp(uint64_t value);
  private:
  uint64_t _internal_expirytimestamp() const;
  void _internal_set_expirytimestamp(uint64_t value);
  public:

  // optional bool futureproofed = 8;
  bool has_futureproofed() const;
  private:
  bool _internal_has_futureproofed() const;
  public:
  void clear_futureproofed();
  bool futureproofed() const;
  void set_futureproofed(bool value);
  private:
  bool _internal_futureproofed() const;
  void _internal_set_futureproofed(bool value);
  public:

  // optional bool useNoviFiatFormat = 11;
  bool has_usenovifiatformat() const;
  private:
  bool _internal_has_usenovifiatformat() const;
  public:
  void clear_usenovifiatformat();
  bool usenovifiatformat() const;
  void set_usenovifiatformat(bool value);
  private:
  bool _internal_usenovifiatformat() const;
  void _internal_set_usenovifiatformat(bool value);
  public:

  // optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
  bool has_txnstatus() const;
  private:
  bool _internal_has_txnstatus() const;
  public:
  void clear_txnstatus();
  ::proto::PaymentInfo_TxnStatus txnstatus() const;
  void set_txnstatus(::proto::PaymentInfo_TxnStatus value);
  private:
  ::proto::PaymentInfo_TxnStatus _internal_txnstatus() const;
  void _internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PaymentInfo)
 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 receiverjid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currency_;
    ::proto::MessageKey* requestmessagekey_;
    ::proto::Money* primaryamount_;
    ::proto::Money* exchangeamount_;
    uint64_t amount1000_;
    int currencydeprecated_;
    int status_;
    uint64_t transactiontimestamp_;
    uint64_t expirytimestamp_;
    bool futureproofed_;
    bool usenovifiatformat_;
    int txnstatus_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PendingKeyExchange final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingKeyExchange) */ {
 public:
  inline PendingKeyExchange() : PendingKeyExchange(nullptr) {}
  ~PendingKeyExchange() override;
  explicit PROTOBUF_CONSTEXPR PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PendingKeyExchange(const PendingKeyExchange& from);
  PendingKeyExchange(PendingKeyExchange&& from) noexcept
    : PendingKeyExchange() {
    *this = ::std::move(from);
  }

  inline PendingKeyExchange& operator=(const PendingKeyExchange& from) {
    CopyFrom(from);
    return *this;
  }
  inline PendingKeyExchange& operator=(PendingKeyExchange&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PendingKeyExchange& default_instance() {
    return *internal_default_instance();
  }
  static inline const PendingKeyExchange* internal_default_instance() {
    return reinterpret_cast<const PendingKeyExchange*>(
               &_PendingKeyExchange_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    152;

  friend void swap(PendingKeyExchange& a, PendingKeyExchange& b) {
    a.Swap(&b);
  }
  inline void Swap(PendingKeyExchange* 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(PendingKeyExchange* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PendingKeyExchange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PendingKeyExchange>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PendingKeyExchange& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PendingKeyExchange& from) {
    PendingKeyExchange::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PendingKeyExchange* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PendingKeyExchange";
  }
  protected:
  explicit PendingKeyExchange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLocalBaseKeyFieldNumber = 2,
    kLocalBaseKeyPrivateFieldNumber = 3,
    kLocalRatchetKeyFieldNumber = 4,
    kLocalRatchetKeyPrivateFieldNumber = 5,
    kLocalIdentityKeyFieldNumber = 7,
    kLocalIdentityKeyPrivateFieldNumber = 8,
    kSequenceFieldNumber = 1,
  };
  // optional bytes localBaseKey = 2;
  bool has_localbasekey() const;
  private:
  bool _internal_has_localbasekey() const;
  public:
  void clear_localbasekey();
  const std::string& localbasekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localbasekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localbasekey();
  PROTOBUF_NODISCARD std::string* release_localbasekey();
  void set_allocated_localbasekey(std::string* localbasekey);
  private:
  const std::string& _internal_localbasekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekey(const std::string& value);
  std::string* _internal_mutable_localbasekey();
  public:

  // optional bytes localBaseKeyPrivate = 3;
  bool has_localbasekeyprivate() const;
  private:
  bool _internal_has_localbasekeyprivate() const;
  public:
  void clear_localbasekeyprivate();
  const std::string& localbasekeyprivate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localbasekeyprivate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localbasekeyprivate();
  PROTOBUF_NODISCARD std::string* release_localbasekeyprivate();
  void set_allocated_localbasekeyprivate(std::string* localbasekeyprivate);
  private:
  const std::string& _internal_localbasekeyprivate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localbasekeyprivate(const std::string& value);
  std::string* _internal_mutable_localbasekeyprivate();
  public:

  // optional bytes localRatchetKey = 4;
  bool has_localratchetkey() const;
  private:
  bool _internal_has_localratchetkey() const;
  public:
  void clear_localratchetkey();
  const std::string& localratchetkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localratchetkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localratchetkey();
  PROTOBUF_NODISCARD std::string* release_localratchetkey();
  void set_allocated_localratchetkey(std::string* localratchetkey);
  private:
  const std::string& _internal_localratchetkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkey(const std::string& value);
  std::string* _internal_mutable_localratchetkey();
  public:

  // optional bytes localRatchetKeyPrivate = 5;
  bool has_localratchetkeyprivate() const;
  private:
  bool _internal_has_localratchetkeyprivate() const;
  public:
  void clear_localratchetkeyprivate();
  const std::string& localratchetkeyprivate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localratchetkeyprivate();
  PROTOBUF_NODISCARD std::string* release_localratchetkeyprivate();
  void set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate);
  private:
  const std::string& _internal_localratchetkeyprivate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localratchetkeyprivate(const std::string& value);
  std::string* _internal_mutable_localratchetkeyprivate();
  public:

  // optional bytes localIdentityKey = 7;
  bool has_localidentitykey() const;
  private:
  bool _internal_has_localidentitykey() const;
  public:
  void clear_localidentitykey();
  const std::string& localidentitykey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localidentitykey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localidentitykey();
  PROTOBUF_NODISCARD std::string* release_localidentitykey();
  void set_allocated_localidentitykey(std::string* localidentitykey);
  private:
  const std::string& _internal_localidentitykey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykey(const std::string& value);
  std::string* _internal_mutable_localidentitykey();
  public:

  // optional bytes localIdentityKeyPrivate = 8;
  bool has_localidentitykeyprivate() const;
  private:
  bool _internal_has_localidentitykeyprivate() const;
  public:
  void clear_localidentitykeyprivate();
  const std::string& localidentitykeyprivate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localidentitykeyprivate();
  PROTOBUF_NODISCARD std::string* release_localidentitykeyprivate();
  void set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate);
  private:
  const std::string& _internal_localidentitykeyprivate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitykeyprivate(const std::string& value);
  std::string* _internal_mutable_localidentitykeyprivate();
  public:

  // optional uint32 sequence = 1;
  bool has_sequence() const;
  private:
  bool _internal_has_sequence() const;
  public:
  void clear_sequence();
  uint32_t sequence() const;
  void set_sequence(uint32_t value);
  private:
  uint32_t _internal_sequence() const;
  void _internal_set_sequence(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PendingKeyExchange)
 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 localbasekey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localbasekeyprivate_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localratchetkeyprivate_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitykeyprivate_;
    uint32_t sequence_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PendingPreKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PendingPreKey) */ {
 public:
  inline PendingPreKey() : PendingPreKey(nullptr) {}
  ~PendingPreKey() override;
  explicit PROTOBUF_CONSTEXPR PendingPreKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PendingPreKey(const PendingPreKey& from);
  PendingPreKey(PendingPreKey&& from) noexcept
    : PendingPreKey() {
    *this = ::std::move(from);
  }

  inline PendingPreKey& operator=(const PendingPreKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline PendingPreKey& operator=(PendingPreKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PendingPreKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const PendingPreKey* internal_default_instance() {
    return reinterpret_cast<const PendingPreKey*>(
               &_PendingPreKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    153;

  friend void swap(PendingPreKey& a, PendingPreKey& b) {
    a.Swap(&b);
  }
  inline void Swap(PendingPreKey* 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(PendingPreKey* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PendingPreKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PendingPreKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PendingPreKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PendingPreKey& from) {
    PendingPreKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PendingPreKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PendingPreKey";
  }
  protected:
  explicit PendingPreKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBaseKeyFieldNumber = 2,
    kPreKeyIdFieldNumber = 1,
    kSignedPreKeyIdFieldNumber = 3,
  };
  // optional bytes baseKey = 2;
  bool has_basekey() const;
  private:
  bool _internal_has_basekey() const;
  public:
  void clear_basekey();
  const std::string& basekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_basekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_basekey();
  PROTOBUF_NODISCARD std::string* release_basekey();
  void set_allocated_basekey(std::string* basekey);
  private:
  const std::string& _internal_basekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_basekey(const std::string& value);
  std::string* _internal_mutable_basekey();
  public:

  // optional uint32 preKeyId = 1;
  bool has_prekeyid() const;
  private:
  bool _internal_has_prekeyid() const;
  public:
  void clear_prekeyid();
  uint32_t prekeyid() const;
  void set_prekeyid(uint32_t value);
  private:
  uint32_t _internal_prekeyid() const;
  void _internal_set_prekeyid(uint32_t value);
  public:

  // optional int32 signedPreKeyId = 3;
  bool has_signedprekeyid() const;
  private:
  bool _internal_has_signedprekeyid() const;
  public:
  void clear_signedprekeyid();
  int32_t signedprekeyid() const;
  void set_signedprekeyid(int32_t value);
  private:
  int32_t _internal_signedprekeyid() const;
  void _internal_set_signedprekeyid(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PendingPreKey)
 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 basekey_;
    uint32_t prekeyid_;
    int32_t signedprekeyid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PhotoChange final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PhotoChange) */ {
 public:
  inline PhotoChange() : PhotoChange(nullptr) {}
  ~PhotoChange() override;
  explicit PROTOBUF_CONSTEXPR PhotoChange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PhotoChange(const PhotoChange& from);
  PhotoChange(PhotoChange&& from) noexcept
    : PhotoChange() {
    *this = ::std::move(from);
  }

  inline PhotoChange& operator=(const PhotoChange& from) {
    CopyFrom(from);
    return *this;
  }
  inline PhotoChange& operator=(PhotoChange&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PhotoChange& default_instance() {
    return *internal_default_instance();
  }
  static inline const PhotoChange* internal_default_instance() {
    return reinterpret_cast<const PhotoChange*>(
               &_PhotoChange_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    154;

  friend void swap(PhotoChange& a, PhotoChange& b) {
    a.Swap(&b);
  }
  inline void Swap(PhotoChange* 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(PhotoChange* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PhotoChange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PhotoChange>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PhotoChange& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PhotoChange& from) {
    PhotoChange::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PhotoChange* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PhotoChange";
  }
  protected:
  explicit PhotoChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOldPhotoFieldNumber = 1,
    kNewPhotoFieldNumber = 2,
    kNewPhotoIdFieldNumber = 3,
  };
  // optional bytes oldPhoto = 1;
  bool has_oldphoto() const;
  private:
  bool _internal_has_oldphoto() const;
  public:
  void clear_oldphoto();
  const std::string& oldphoto() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_oldphoto(ArgT0&& arg0, ArgT... args);
  std::string* mutable_oldphoto();
  PROTOBUF_NODISCARD std::string* release_oldphoto();
  void set_allocated_oldphoto(std::string* oldphoto);
  private:
  const std::string& _internal_oldphoto() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oldphoto(const std::string& value);
  std::string* _internal_mutable_oldphoto();
  public:

  // optional bytes newPhoto = 2;
  bool has_newphoto() const;
  private:
  bool _internal_has_newphoto() const;
  public:
  void clear_newphoto();
  const std::string& newphoto() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_newphoto(ArgT0&& arg0, ArgT... args);
  std::string* mutable_newphoto();
  PROTOBUF_NODISCARD std::string* release_newphoto();
  void set_allocated_newphoto(std::string* newphoto);
  private:
  const std::string& _internal_newphoto() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_newphoto(const std::string& value);
  std::string* _internal_mutable_newphoto();
  public:

  // optional uint32 newPhotoId = 3;
  bool has_newphotoid() const;
  private:
  bool _internal_has_newphotoid() const;
  public:
  void clear_newphotoid();
  uint32_t newphotoid() const;
  void set_newphotoid(uint32_t value);
  private:
  uint32_t _internal_newphotoid() const;
  void _internal_set_newphotoid(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PhotoChange)
 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 oldphoto_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr newphoto_;
    uint32_t newphotoid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Point final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Point) */ {
 public:
  inline Point() : Point(nullptr) {}
  ~Point() override;
  explicit PROTOBUF_CONSTEXPR Point(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Point(const Point& from);
  Point(Point&& from) noexcept
    : Point() {
    *this = ::std::move(from);
  }

  inline Point& operator=(const Point& from) {
    CopyFrom(from);
    return *this;
  }
  inline Point& operator=(Point&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Point& default_instance() {
    return *internal_default_instance();
  }
  static inline const Point* internal_default_instance() {
    return reinterpret_cast<const Point*>(
               &_Point_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    155;

  friend void swap(Point& a, Point& b) {
    a.Swap(&b);
  }
  inline void Swap(Point* 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(Point* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Point* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Point>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Point& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Point& from) {
    Point::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Point* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Point";
  }
  protected:
  explicit Point(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kXDeprecatedFieldNumber = 1,
    kYDeprecatedFieldNumber = 2,
    kXFieldNumber = 3,
    kYFieldNumber = 4,
  };
  // optional int32 xDeprecated = 1;
  bool has_xdeprecated() const;
  private:
  bool _internal_has_xdeprecated() const;
  public:
  void clear_xdeprecated();
  int32_t xdeprecated() const;
  void set_xdeprecated(int32_t value);
  private:
  int32_t _internal_xdeprecated() const;
  void _internal_set_xdeprecated(int32_t value);
  public:

  // optional int32 yDeprecated = 2;
  bool has_ydeprecated() const;
  private:
  bool _internal_has_ydeprecated() const;
  public:
  void clear_ydeprecated();
  int32_t ydeprecated() const;
  void set_ydeprecated(int32_t value);
  private:
  int32_t _internal_ydeprecated() const;
  void _internal_set_ydeprecated(int32_t value);
  public:

  // optional double x = 3;
  bool has_x() const;
  private:
  bool _internal_has_x() const;
  public:
  void clear_x();
  double x() const;
  void set_x(double value);
  private:
  double _internal_x() const;
  void _internal_set_x(double value);
  public:

  // optional double y = 4;
  bool has_y() const;
  private:
  bool _internal_has_y() const;
  public:
  void clear_y();
  double y() const;
  void set_y(double value);
  private:
  double _internal_y() const;
  void _internal_set_y(double value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Point)
 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_;
    int32_t xdeprecated_;
    int32_t ydeprecated_;
    double x_;
    double y_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PollAdditionalMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollAdditionalMetadata) */ {
 public:
  inline PollAdditionalMetadata() : PollAdditionalMetadata(nullptr) {}
  ~PollAdditionalMetadata() override;
  explicit PROTOBUF_CONSTEXPR PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PollAdditionalMetadata(const PollAdditionalMetadata& from);
  PollAdditionalMetadata(PollAdditionalMetadata&& from) noexcept
    : PollAdditionalMetadata() {
    *this = ::std::move(from);
  }

  inline PollAdditionalMetadata& operator=(const PollAdditionalMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline PollAdditionalMetadata& operator=(PollAdditionalMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PollAdditionalMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const PollAdditionalMetadata* internal_default_instance() {
    return reinterpret_cast<const PollAdditionalMetadata*>(
               &_PollAdditionalMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    156;

  friend void swap(PollAdditionalMetadata& a, PollAdditionalMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(PollAdditionalMetadata* 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(PollAdditionalMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PollAdditionalMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PollAdditionalMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PollAdditionalMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PollAdditionalMetadata& from) {
    PollAdditionalMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PollAdditionalMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PollAdditionalMetadata";
  }
  protected:
  explicit PollAdditionalMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPollInvalidatedFieldNumber = 1,
  };
  // optional bool pollInvalidated = 1;
  bool has_pollinvalidated() const;
  private:
  bool _internal_has_pollinvalidated() const;
  public:
  void clear_pollinvalidated();
  bool pollinvalidated() const;
  void set_pollinvalidated(bool value);
  private:
  bool _internal_pollinvalidated() const;
  void _internal_set_pollinvalidated(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PollAdditionalMetadata)
 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 pollinvalidated_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PollEncValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollEncValue) */ {
 public:
  inline PollEncValue() : PollEncValue(nullptr) {}
  ~PollEncValue() override;
  explicit PROTOBUF_CONSTEXPR PollEncValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PollEncValue(const PollEncValue& from);
  PollEncValue(PollEncValue&& from) noexcept
    : PollEncValue() {
    *this = ::std::move(from);
  }

  inline PollEncValue& operator=(const PollEncValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline PollEncValue& operator=(PollEncValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PollEncValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const PollEncValue* internal_default_instance() {
    return reinterpret_cast<const PollEncValue*>(
               &_PollEncValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    157;

  friend void swap(PollEncValue& a, PollEncValue& b) {
    a.Swap(&b);
  }
  inline void Swap(PollEncValue* 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(PollEncValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PollEncValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PollEncValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PollEncValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PollEncValue& from) {
    PollEncValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PollEncValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PollEncValue";
  }
  protected:
  explicit PollEncValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEncPayloadFieldNumber = 1,
    kEncIvFieldNumber = 2,
  };
  // optional bytes encPayload = 1;
  bool has_encpayload() const;
  private:
  bool _internal_has_encpayload() const;
  public:
  void clear_encpayload();
  const std::string& encpayload() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encpayload(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encpayload();
  PROTOBUF_NODISCARD std::string* release_encpayload();
  void set_allocated_encpayload(std::string* encpayload);
  private:
  const std::string& _internal_encpayload() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encpayload(const std::string& value);
  std::string* _internal_mutable_encpayload();
  public:

  // optional bytes encIv = 2;
  bool has_enciv() const;
  private:
  bool _internal_has_enciv() const;
  public:
  void clear_enciv();
  const std::string& enciv() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_enciv(ArgT0&& arg0, ArgT... args);
  std::string* mutable_enciv();
  PROTOBUF_NODISCARD std::string* release_enciv();
  void set_allocated_enciv(std::string* enciv);
  private:
  const std::string& _internal_enciv() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_enciv(const std::string& value);
  std::string* _internal_mutable_enciv();
  public:

  // @@protoc_insertion_point(class_scope:proto.PollEncValue)
 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 encpayload_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enciv_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PollUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PollUpdate) */ {
 public:
  inline PollUpdate() : PollUpdate(nullptr) {}
  ~PollUpdate() override;
  explicit PROTOBUF_CONSTEXPR PollUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PollUpdate(const PollUpdate& from);
  PollUpdate(PollUpdate&& from) noexcept
    : PollUpdate() {
    *this = ::std::move(from);
  }

  inline PollUpdate& operator=(const PollUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline PollUpdate& operator=(PollUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PollUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const PollUpdate* internal_default_instance() {
    return reinterpret_cast<const PollUpdate*>(
               &_PollUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    158;

  friend void swap(PollUpdate& a, PollUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(PollUpdate* 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(PollUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PollUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PollUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PollUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PollUpdate& from) {
    PollUpdate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PollUpdate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PollUpdate";
  }
  protected:
  explicit PollUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPollUpdateMessageKeyFieldNumber = 1,
    kVoteFieldNumber = 2,
    kSenderTimestampMsFieldNumber = 3,
  };
  // optional .proto.MessageKey pollUpdateMessageKey = 1;
  bool has_pollupdatemessagekey() const;
  private:
  bool _internal_has_pollupdatemessagekey() const;
  public:
  void clear_pollupdatemessagekey();
  const ::proto::MessageKey& pollupdatemessagekey() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_pollupdatemessagekey();
  ::proto::MessageKey* mutable_pollupdatemessagekey();
  void set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey);
  private:
  const ::proto::MessageKey& _internal_pollupdatemessagekey() const;
  ::proto::MessageKey* _internal_mutable_pollupdatemessagekey();
  public:
  void unsafe_arena_set_allocated_pollupdatemessagekey(
      ::proto::MessageKey* pollupdatemessagekey);
  ::proto::MessageKey* unsafe_arena_release_pollupdatemessagekey();

  // optional .proto.Message.PollVoteMessage vote = 2;
  bool has_vote() const;
  private:
  bool _internal_has_vote() const;
  public:
  void clear_vote();
  const ::proto::Message_PollVoteMessage& vote() const;
  PROTOBUF_NODISCARD ::proto::Message_PollVoteMessage* release_vote();
  ::proto::Message_PollVoteMessage* mutable_vote();
  void set_allocated_vote(::proto::Message_PollVoteMessage* vote);
  private:
  const ::proto::Message_PollVoteMessage& _internal_vote() const;
  ::proto::Message_PollVoteMessage* _internal_mutable_vote();
  public:
  void unsafe_arena_set_allocated_vote(
      ::proto::Message_PollVoteMessage* vote);
  ::proto::Message_PollVoteMessage* unsafe_arena_release_vote();

  // optional int64 senderTimestampMs = 3;
  bool has_sendertimestampms() const;
  private:
  bool _internal_has_sendertimestampms() const;
  public:
  void clear_sendertimestampms();
  int64_t sendertimestampms() const;
  void set_sendertimestampms(int64_t value);
  private:
  int64_t _internal_sendertimestampms() const;
  void _internal_set_sendertimestampms(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PollUpdate)
 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_;
    ::proto::MessageKey* pollupdatemessagekey_;
    ::proto::Message_PollVoteMessage* vote_;
    int64_t sendertimestampms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class PreKeyRecordStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.PreKeyRecordStructure) */ {
 public:
  inline PreKeyRecordStructure() : PreKeyRecordStructure(nullptr) {}
  ~PreKeyRecordStructure() override;
  explicit PROTOBUF_CONSTEXPR PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PreKeyRecordStructure(const PreKeyRecordStructure& from);
  PreKeyRecordStructure(PreKeyRecordStructure&& from) noexcept
    : PreKeyRecordStructure() {
    *this = ::std::move(from);
  }

  inline PreKeyRecordStructure& operator=(const PreKeyRecordStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline PreKeyRecordStructure& operator=(PreKeyRecordStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PreKeyRecordStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const PreKeyRecordStructure* internal_default_instance() {
    return reinterpret_cast<const PreKeyRecordStructure*>(
               &_PreKeyRecordStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    159;

  friend void swap(PreKeyRecordStructure& a, PreKeyRecordStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(PreKeyRecordStructure* 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(PreKeyRecordStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  PreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PreKeyRecordStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PreKeyRecordStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const PreKeyRecordStructure& from) {
    PreKeyRecordStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PreKeyRecordStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.PreKeyRecordStructure";
  }
  protected:
  explicit PreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPublicKeyFieldNumber = 2,
    kPrivateKeyFieldNumber = 3,
    kIdFieldNumber = 1,
  };
  // optional bytes publicKey = 2;
  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:

  // optional bytes privateKey = 3;
  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:

  // optional uint32 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.PreKeyRecordStructure)
 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 publickey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
    uint32_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Pushname final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Pushname) */ {
 public:
  inline Pushname() : Pushname(nullptr) {}
  ~Pushname() override;
  explicit PROTOBUF_CONSTEXPR Pushname(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Pushname(const Pushname& from);
  Pushname(Pushname&& from) noexcept
    : Pushname() {
    *this = ::std::move(from);
  }

  inline Pushname& operator=(const Pushname& from) {
    CopyFrom(from);
    return *this;
  }
  inline Pushname& operator=(Pushname&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Pushname& default_instance() {
    return *internal_default_instance();
  }
  static inline const Pushname* internal_default_instance() {
    return reinterpret_cast<const Pushname*>(
               &_Pushname_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    160;

  friend void swap(Pushname& a, Pushname& b) {
    a.Swap(&b);
  }
  inline void Swap(Pushname* 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(Pushname* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Pushname* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Pushname>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Pushname& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Pushname& from) {
    Pushname::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Pushname* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Pushname";
  }
  protected:
  explicit Pushname(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 1,
    kPushnameFieldNumber = 2,
  };
  // optional string id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional string pushname = 2;
  bool has_pushname() const;
  private:
  bool _internal_has_pushname() const;
  public:
  void clear_pushname();
  const std::string& pushname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pushname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pushname();
  PROTOBUF_NODISCARD std::string* release_pushname();
  void set_allocated_pushname(std::string* pushname);
  private:
  const std::string& _internal_pushname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
  std::string* _internal_mutable_pushname();
  public:

  // @@protoc_insertion_point(class_scope:proto.Pushname)
 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 id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class Reaction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Reaction) */ {
 public:
  inline Reaction() : Reaction(nullptr) {}
  ~Reaction() override;
  explicit PROTOBUF_CONSTEXPR Reaction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Reaction(const Reaction& from);
  Reaction(Reaction&& from) noexcept
    : Reaction() {
    *this = ::std::move(from);
  }

  inline Reaction& operator=(const Reaction& from) {
    CopyFrom(from);
    return *this;
  }
  inline Reaction& operator=(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 ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Reaction& default_instance() {
    return *internal_default_instance();
  }
  static inline const Reaction* internal_default_instance() {
    return reinterpret_cast<const Reaction*>(
               &_Reaction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    161;

  friend void swap(Reaction& a, Reaction& b) {
    a.Swap(&b);
  }
  inline void Swap(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(Reaction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  Reaction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Reaction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Reaction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const Reaction& from) {
    Reaction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Reaction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.Reaction";
  }
  protected:
  explicit Reaction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 2,
    kGroupingKeyFieldNumber = 3,
    kKeyFieldNumber = 1,
    kSenderTimestampMsFieldNumber = 4,
    kUnreadFieldNumber = 5,
  };
  // optional string text = 2;
  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:

  // optional string groupingKey = 3;
  bool has_groupingkey() const;
  private:
  bool _internal_has_groupingkey() const;
  public:
  void clear_groupingkey();
  const std::string& groupingkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_groupingkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_groupingkey();
  PROTOBUF_NODISCARD std::string* release_groupingkey();
  void set_allocated_groupingkey(std::string* groupingkey);
  private:
  const std::string& _internal_groupingkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_groupingkey(const std::string& value);
  std::string* _internal_mutable_groupingkey();
  public:

  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional int64 senderTimestampMs = 4;
  bool has_sendertimestampms() const;
  private:
  bool _internal_has_sendertimestampms() const;
  public:
  void clear_sendertimestampms();
  int64_t sendertimestampms() const;
  void set_sendertimestampms(int64_t value);
  private:
  int64_t _internal_sendertimestampms() const;
  void _internal_set_sendertimestampms(int64_t value);
  public:

  // optional bool unread = 5;
  bool has_unread() const;
  private:
  bool _internal_has_unread() const;
  public:
  void clear_unread();
  bool unread() const;
  void set_unread(bool value);
  private:
  bool _internal_unread() const;
  void _internal_set_unread(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.Reaction)
 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 text_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr groupingkey_;
    ::proto::MessageKey* key_;
    int64_t sendertimestampms_;
    bool unread_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class RecentEmojiWeight final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecentEmojiWeight) */ {
 public:
  inline RecentEmojiWeight() : RecentEmojiWeight(nullptr) {}
  ~RecentEmojiWeight() override;
  explicit PROTOBUF_CONSTEXPR RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RecentEmojiWeight(const RecentEmojiWeight& from);
  RecentEmojiWeight(RecentEmojiWeight&& from) noexcept
    : RecentEmojiWeight() {
    *this = ::std::move(from);
  }

  inline RecentEmojiWeight& operator=(const RecentEmojiWeight& from) {
    CopyFrom(from);
    return *this;
  }
  inline RecentEmojiWeight& operator=(RecentEmojiWeight&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RecentEmojiWeight& default_instance() {
    return *internal_default_instance();
  }
  static inline const RecentEmojiWeight* internal_default_instance() {
    return reinterpret_cast<const RecentEmojiWeight*>(
               &_RecentEmojiWeight_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    162;

  friend void swap(RecentEmojiWeight& a, RecentEmojiWeight& b) {
    a.Swap(&b);
  }
  inline void Swap(RecentEmojiWeight* 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(RecentEmojiWeight* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RecentEmojiWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RecentEmojiWeight>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RecentEmojiWeight& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RecentEmojiWeight& from) {
    RecentEmojiWeight::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RecentEmojiWeight* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.RecentEmojiWeight";
  }
  protected:
  explicit RecentEmojiWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEmojiFieldNumber = 1,
    kWeightFieldNumber = 2,
  };
  // optional string emoji = 1;
  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:

  // optional float weight = 2;
  bool has_weight() const;
  private:
  bool _internal_has_weight() const;
  public:
  void clear_weight();
  float weight() const;
  void set_weight(float value);
  private:
  float _internal_weight() const;
  void _internal_set_weight(float value);
  public:

  // @@protoc_insertion_point(class_scope:proto.RecentEmojiWeight)
 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 emoji_;
    float weight_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class RecordStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.RecordStructure) */ {
 public:
  inline RecordStructure() : RecordStructure(nullptr) {}
  ~RecordStructure() override;
  explicit PROTOBUF_CONSTEXPR RecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RecordStructure(const RecordStructure& from);
  RecordStructure(RecordStructure&& from) noexcept
    : RecordStructure() {
    *this = ::std::move(from);
  }

  inline RecordStructure& operator=(const RecordStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline RecordStructure& operator=(RecordStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RecordStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const RecordStructure* internal_default_instance() {
    return reinterpret_cast<const RecordStructure*>(
               &_RecordStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    163;

  friend void swap(RecordStructure& a, RecordStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(RecordStructure* 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(RecordStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  RecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RecordStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RecordStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const RecordStructure& from) {
    RecordStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RecordStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.RecordStructure";
  }
  protected:
  explicit RecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPreviousSessionsFieldNumber = 2,
    kCurrentSessionFieldNumber = 1,
  };
  // repeated .proto.SessionStructure previousSessions = 2;
  int previoussessions_size() const;
  private:
  int _internal_previoussessions_size() const;
  public:
  void clear_previoussessions();
  ::proto::SessionStructure* mutable_previoussessions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >*
      mutable_previoussessions();
  private:
  const ::proto::SessionStructure& _internal_previoussessions(int index) const;
  ::proto::SessionStructure* _internal_add_previoussessions();
  public:
  const ::proto::SessionStructure& previoussessions(int index) const;
  ::proto::SessionStructure* add_previoussessions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >&
      previoussessions() const;

  // optional .proto.SessionStructure currentSession = 1;
  bool has_currentsession() const;
  private:
  bool _internal_has_currentsession() const;
  public:
  void clear_currentsession();
  const ::proto::SessionStructure& currentsession() const;
  PROTOBUF_NODISCARD ::proto::SessionStructure* release_currentsession();
  ::proto::SessionStructure* mutable_currentsession();
  void set_allocated_currentsession(::proto::SessionStructure* currentsession);
  private:
  const ::proto::SessionStructure& _internal_currentsession() const;
  ::proto::SessionStructure* _internal_mutable_currentsession();
  public:
  void unsafe_arena_set_allocated_currentsession(
      ::proto::SessionStructure* currentsession);
  ::proto::SessionStructure* unsafe_arena_release_currentsession();

  // @@protoc_insertion_point(class_scope:proto.RecordStructure)
 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< ::proto::SessionStructure > previoussessions_;
    ::proto::SessionStructure* currentsession_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SenderChainKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderChainKey) */ {
 public:
  inline SenderChainKey() : SenderChainKey(nullptr) {}
  ~SenderChainKey() override;
  explicit PROTOBUF_CONSTEXPR SenderChainKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SenderChainKey(const SenderChainKey& from);
  SenderChainKey(SenderChainKey&& from) noexcept
    : SenderChainKey() {
    *this = ::std::move(from);
  }

  inline SenderChainKey& operator=(const SenderChainKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline SenderChainKey& operator=(SenderChainKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SenderChainKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const SenderChainKey* internal_default_instance() {
    return reinterpret_cast<const SenderChainKey*>(
               &_SenderChainKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    164;

  friend void swap(SenderChainKey& a, SenderChainKey& b) {
    a.Swap(&b);
  }
  inline void Swap(SenderChainKey* 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(SenderChainKey* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SenderChainKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SenderChainKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SenderChainKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SenderChainKey& from) {
    SenderChainKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SenderChainKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SenderChainKey";
  }
  protected:
  explicit SenderChainKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSeedFieldNumber = 2,
    kIterationFieldNumber = 1,
  };
  // optional bytes seed = 2;
  bool has_seed() const;
  private:
  bool _internal_has_seed() const;
  public:
  void clear_seed();
  const std::string& seed() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_seed(ArgT0&& arg0, ArgT... args);
  std::string* mutable_seed();
  PROTOBUF_NODISCARD std::string* release_seed();
  void set_allocated_seed(std::string* seed);
  private:
  const std::string& _internal_seed() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value);
  std::string* _internal_mutable_seed();
  public:

  // optional uint32 iteration = 1;
  bool has_iteration() const;
  private:
  bool _internal_has_iteration() const;
  public:
  void clear_iteration();
  uint32_t iteration() const;
  void set_iteration(uint32_t value);
  private:
  uint32_t _internal_iteration() const;
  void _internal_set_iteration(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SenderChainKey)
 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 seed_;
    uint32_t iteration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SenderKeyRecordStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyRecordStructure) */ {
 public:
  inline SenderKeyRecordStructure() : SenderKeyRecordStructure(nullptr) {}
  ~SenderKeyRecordStructure() override;
  explicit PROTOBUF_CONSTEXPR SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SenderKeyRecordStructure(const SenderKeyRecordStructure& from);
  SenderKeyRecordStructure(SenderKeyRecordStructure&& from) noexcept
    : SenderKeyRecordStructure() {
    *this = ::std::move(from);
  }

  inline SenderKeyRecordStructure& operator=(const SenderKeyRecordStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline SenderKeyRecordStructure& operator=(SenderKeyRecordStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SenderKeyRecordStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const SenderKeyRecordStructure* internal_default_instance() {
    return reinterpret_cast<const SenderKeyRecordStructure*>(
               &_SenderKeyRecordStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    165;

  friend void swap(SenderKeyRecordStructure& a, SenderKeyRecordStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(SenderKeyRecordStructure* 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(SenderKeyRecordStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SenderKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SenderKeyRecordStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SenderKeyRecordStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SenderKeyRecordStructure& from) {
    SenderKeyRecordStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SenderKeyRecordStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SenderKeyRecordStructure";
  }
  protected:
  explicit SenderKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSenderKeyStatesFieldNumber = 1,
  };
  // repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
  int senderkeystates_size() const;
  private:
  int _internal_senderkeystates_size() const;
  public:
  void clear_senderkeystates();
  ::proto::SenderKeyStateStructure* mutable_senderkeystates(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >*
      mutable_senderkeystates();
  private:
  const ::proto::SenderKeyStateStructure& _internal_senderkeystates(int index) const;
  ::proto::SenderKeyStateStructure* _internal_add_senderkeystates();
  public:
  const ::proto::SenderKeyStateStructure& senderkeystates(int index) const;
  ::proto::SenderKeyStateStructure* add_senderkeystates();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >&
      senderkeystates() const;

  // @@protoc_insertion_point(class_scope:proto.SenderKeyRecordStructure)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure > senderkeystates_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SenderKeyStateStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderKeyStateStructure) */ {
 public:
  inline SenderKeyStateStructure() : SenderKeyStateStructure(nullptr) {}
  ~SenderKeyStateStructure() override;
  explicit PROTOBUF_CONSTEXPR SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SenderKeyStateStructure(const SenderKeyStateStructure& from);
  SenderKeyStateStructure(SenderKeyStateStructure&& from) noexcept
    : SenderKeyStateStructure() {
    *this = ::std::move(from);
  }

  inline SenderKeyStateStructure& operator=(const SenderKeyStateStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline SenderKeyStateStructure& operator=(SenderKeyStateStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SenderKeyStateStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const SenderKeyStateStructure* internal_default_instance() {
    return reinterpret_cast<const SenderKeyStateStructure*>(
               &_SenderKeyStateStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    166;

  friend void swap(SenderKeyStateStructure& a, SenderKeyStateStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(SenderKeyStateStructure* 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(SenderKeyStateStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SenderKeyStateStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SenderKeyStateStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SenderKeyStateStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SenderKeyStateStructure& from) {
    SenderKeyStateStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SenderKeyStateStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SenderKeyStateStructure";
  }
  protected:
  explicit SenderKeyStateStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSenderMessageKeysFieldNumber = 4,
    kSenderChainKeyFieldNumber = 2,
    kSenderSigningKeyFieldNumber = 3,
    kSenderKeyIdFieldNumber = 1,
  };
  // repeated .proto.SenderMessageKey senderMessageKeys = 4;
  int sendermessagekeys_size() const;
  private:
  int _internal_sendermessagekeys_size() const;
  public:
  void clear_sendermessagekeys();
  ::proto::SenderMessageKey* mutable_sendermessagekeys(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >*
      mutable_sendermessagekeys();
  private:
  const ::proto::SenderMessageKey& _internal_sendermessagekeys(int index) const;
  ::proto::SenderMessageKey* _internal_add_sendermessagekeys();
  public:
  const ::proto::SenderMessageKey& sendermessagekeys(int index) const;
  ::proto::SenderMessageKey* add_sendermessagekeys();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >&
      sendermessagekeys() const;

  // optional .proto.SenderChainKey senderChainKey = 2;
  bool has_senderchainkey() const;
  private:
  bool _internal_has_senderchainkey() const;
  public:
  void clear_senderchainkey();
  const ::proto::SenderChainKey& senderchainkey() const;
  PROTOBUF_NODISCARD ::proto::SenderChainKey* release_senderchainkey();
  ::proto::SenderChainKey* mutable_senderchainkey();
  void set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey);
  private:
  const ::proto::SenderChainKey& _internal_senderchainkey() const;
  ::proto::SenderChainKey* _internal_mutable_senderchainkey();
  public:
  void unsafe_arena_set_allocated_senderchainkey(
      ::proto::SenderChainKey* senderchainkey);
  ::proto::SenderChainKey* unsafe_arena_release_senderchainkey();

  // optional .proto.SenderSigningKey senderSigningKey = 3;
  bool has_sendersigningkey() const;
  private:
  bool _internal_has_sendersigningkey() const;
  public:
  void clear_sendersigningkey();
  const ::proto::SenderSigningKey& sendersigningkey() const;
  PROTOBUF_NODISCARD ::proto::SenderSigningKey* release_sendersigningkey();
  ::proto::SenderSigningKey* mutable_sendersigningkey();
  void set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey);
  private:
  const ::proto::SenderSigningKey& _internal_sendersigningkey() const;
  ::proto::SenderSigningKey* _internal_mutable_sendersigningkey();
  public:
  void unsafe_arena_set_allocated_sendersigningkey(
      ::proto::SenderSigningKey* sendersigningkey);
  ::proto::SenderSigningKey* unsafe_arena_release_sendersigningkey();

  // optional uint32 senderKeyId = 1;
  bool has_senderkeyid() const;
  private:
  bool _internal_has_senderkeyid() const;
  public:
  void clear_senderkeyid();
  uint32_t senderkeyid() const;
  void set_senderkeyid(uint32_t value);
  private:
  uint32_t _internal_senderkeyid() const;
  void _internal_set_senderkeyid(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SenderKeyStateStructure)
 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< ::proto::SenderMessageKey > sendermessagekeys_;
    ::proto::SenderChainKey* senderchainkey_;
    ::proto::SenderSigningKey* sendersigningkey_;
    uint32_t senderkeyid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SenderMessageKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderMessageKey) */ {
 public:
  inline SenderMessageKey() : SenderMessageKey(nullptr) {}
  ~SenderMessageKey() override;
  explicit PROTOBUF_CONSTEXPR SenderMessageKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SenderMessageKey(const SenderMessageKey& from);
  SenderMessageKey(SenderMessageKey&& from) noexcept
    : SenderMessageKey() {
    *this = ::std::move(from);
  }

  inline SenderMessageKey& operator=(const SenderMessageKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline SenderMessageKey& operator=(SenderMessageKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SenderMessageKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const SenderMessageKey* internal_default_instance() {
    return reinterpret_cast<const SenderMessageKey*>(
               &_SenderMessageKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    167;

  friend void swap(SenderMessageKey& a, SenderMessageKey& b) {
    a.Swap(&b);
  }
  inline void Swap(SenderMessageKey* 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(SenderMessageKey* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SenderMessageKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SenderMessageKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SenderMessageKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SenderMessageKey& from) {
    SenderMessageKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SenderMessageKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SenderMessageKey";
  }
  protected:
  explicit SenderMessageKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSeedFieldNumber = 2,
    kIterationFieldNumber = 1,
  };
  // optional bytes seed = 2;
  bool has_seed() const;
  private:
  bool _internal_has_seed() const;
  public:
  void clear_seed();
  const std::string& seed() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_seed(ArgT0&& arg0, ArgT... args);
  std::string* mutable_seed();
  PROTOBUF_NODISCARD std::string* release_seed();
  void set_allocated_seed(std::string* seed);
  private:
  const std::string& _internal_seed() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_seed(const std::string& value);
  std::string* _internal_mutable_seed();
  public:

  // optional uint32 iteration = 1;
  bool has_iteration() const;
  private:
  bool _internal_has_iteration() const;
  public:
  void clear_iteration();
  uint32_t iteration() const;
  void set_iteration(uint32_t value);
  private:
  uint32_t _internal_iteration() const;
  void _internal_set_iteration(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SenderMessageKey)
 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 seed_;
    uint32_t iteration_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SenderSigningKey final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SenderSigningKey) */ {
 public:
  inline SenderSigningKey() : SenderSigningKey(nullptr) {}
  ~SenderSigningKey() override;
  explicit PROTOBUF_CONSTEXPR SenderSigningKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SenderSigningKey(const SenderSigningKey& from);
  SenderSigningKey(SenderSigningKey&& from) noexcept
    : SenderSigningKey() {
    *this = ::std::move(from);
  }

  inline SenderSigningKey& operator=(const SenderSigningKey& from) {
    CopyFrom(from);
    return *this;
  }
  inline SenderSigningKey& operator=(SenderSigningKey&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SenderSigningKey& default_instance() {
    return *internal_default_instance();
  }
  static inline const SenderSigningKey* internal_default_instance() {
    return reinterpret_cast<const SenderSigningKey*>(
               &_SenderSigningKey_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    168;

  friend void swap(SenderSigningKey& a, SenderSigningKey& b) {
    a.Swap(&b);
  }
  inline void Swap(SenderSigningKey* 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(SenderSigningKey* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SenderSigningKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SenderSigningKey>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SenderSigningKey& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SenderSigningKey& from) {
    SenderSigningKey::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SenderSigningKey* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SenderSigningKey";
  }
  protected:
  explicit SenderSigningKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPublicFieldNumber = 1,
    kPrivateFieldNumber = 2,
  };
  // optional bytes public = 1;
  bool has_public_() const;
  private:
  bool _internal_has_public_() const;
  public:
  void clear_public_();
  const std::string& public_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_public_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_public_();
  PROTOBUF_NODISCARD std::string* release_public_();
  void set_allocated_public_(std::string* public_);
  private:
  const std::string& _internal_public_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_(const std::string& value);
  std::string* _internal_mutable_public_();
  public:

  // optional bytes private = 2;
  bool has_private_() const;
  private:
  bool _internal_has_private_() const;
  public:
  void clear_private_();
  const std::string& private_() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_private_(ArgT0&& arg0, ArgT... args);
  std::string* mutable_private_();
  PROTOBUF_NODISCARD std::string* release_private_();
  void set_allocated_private_(std::string* private_);
  private:
  const std::string& _internal_private_() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_private_(const std::string& value);
  std::string* _internal_mutable_private_();
  public:

  // @@protoc_insertion_point(class_scope:proto.SenderSigningKey)
 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 public__;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr private__;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class ServerErrorReceipt final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ServerErrorReceipt) */ {
 public:
  inline ServerErrorReceipt() : ServerErrorReceipt(nullptr) {}
  ~ServerErrorReceipt() override;
  explicit PROTOBUF_CONSTEXPR ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ServerErrorReceipt(const ServerErrorReceipt& from);
  ServerErrorReceipt(ServerErrorReceipt&& from) noexcept
    : ServerErrorReceipt() {
    *this = ::std::move(from);
  }

  inline ServerErrorReceipt& operator=(const ServerErrorReceipt& from) {
    CopyFrom(from);
    return *this;
  }
  inline ServerErrorReceipt& operator=(ServerErrorReceipt&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ServerErrorReceipt& default_instance() {
    return *internal_default_instance();
  }
  static inline const ServerErrorReceipt* internal_default_instance() {
    return reinterpret_cast<const ServerErrorReceipt*>(
               &_ServerErrorReceipt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    169;

  friend void swap(ServerErrorReceipt& a, ServerErrorReceipt& b) {
    a.Swap(&b);
  }
  inline void Swap(ServerErrorReceipt* 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(ServerErrorReceipt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ServerErrorReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ServerErrorReceipt>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ServerErrorReceipt& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const ServerErrorReceipt& from) {
    ServerErrorReceipt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ServerErrorReceipt* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.ServerErrorReceipt";
  }
  protected:
  explicit ServerErrorReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStanzaIdFieldNumber = 1,
  };
  // optional string stanzaId = 1;
  bool has_stanzaid() const;
  private:
  bool _internal_has_stanzaid() const;
  public:
  void clear_stanzaid();
  const std::string& stanzaid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_stanzaid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_stanzaid();
  PROTOBUF_NODISCARD std::string* release_stanzaid();
  void set_allocated_stanzaid(std::string* stanzaid);
  private:
  const std::string& _internal_stanzaid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stanzaid(const std::string& value);
  std::string* _internal_mutable_stanzaid();
  public:

  // @@protoc_insertion_point(class_scope:proto.ServerErrorReceipt)
 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 stanzaid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SessionStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SessionStructure) */ {
 public:
  inline SessionStructure() : SessionStructure(nullptr) {}
  ~SessionStructure() override;
  explicit PROTOBUF_CONSTEXPR SessionStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SessionStructure(const SessionStructure& from);
  SessionStructure(SessionStructure&& from) noexcept
    : SessionStructure() {
    *this = ::std::move(from);
  }

  inline SessionStructure& operator=(const SessionStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline SessionStructure& operator=(SessionStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SessionStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const SessionStructure* internal_default_instance() {
    return reinterpret_cast<const SessionStructure*>(
               &_SessionStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    170;

  friend void swap(SessionStructure& a, SessionStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(SessionStructure* 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(SessionStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SessionStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SessionStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SessionStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SessionStructure& from) {
    SessionStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SessionStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SessionStructure";
  }
  protected:
  explicit SessionStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kReceiverChainsFieldNumber = 7,
    kLocalIdentityPublicFieldNumber = 2,
    kRemoteIdentityPublicFieldNumber = 3,
    kRootKeyFieldNumber = 4,
    kAliceBaseKeyFieldNumber = 13,
    kSenderChainFieldNumber = 6,
    kPendingKeyExchangeFieldNumber = 8,
    kPendingPreKeyFieldNumber = 9,
    kSessionVersionFieldNumber = 1,
    kPreviousCounterFieldNumber = 5,
    kRemoteRegistrationIdFieldNumber = 10,
    kLocalRegistrationIdFieldNumber = 11,
    kNeedsRefreshFieldNumber = 12,
  };
  // repeated .proto.Chain receiverChains = 7;
  int receiverchains_size() const;
  private:
  int _internal_receiverchains_size() const;
  public:
  void clear_receiverchains();
  ::proto::Chain* mutable_receiverchains(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >*
      mutable_receiverchains();
  private:
  const ::proto::Chain& _internal_receiverchains(int index) const;
  ::proto::Chain* _internal_add_receiverchains();
  public:
  const ::proto::Chain& receiverchains(int index) const;
  ::proto::Chain* add_receiverchains();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >&
      receiverchains() const;

  // optional bytes localIdentityPublic = 2;
  bool has_localidentitypublic() const;
  private:
  bool _internal_has_localidentitypublic() const;
  public:
  void clear_localidentitypublic();
  const std::string& localidentitypublic() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_localidentitypublic(ArgT0&& arg0, ArgT... args);
  std::string* mutable_localidentitypublic();
  PROTOBUF_NODISCARD std::string* release_localidentitypublic();
  void set_allocated_localidentitypublic(std::string* localidentitypublic);
  private:
  const std::string& _internal_localidentitypublic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_localidentitypublic(const std::string& value);
  std::string* _internal_mutable_localidentitypublic();
  public:

  // optional bytes remoteIdentityPublic = 3;
  bool has_remoteidentitypublic() const;
  private:
  bool _internal_has_remoteidentitypublic() const;
  public:
  void clear_remoteidentitypublic();
  const std::string& remoteidentitypublic() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_remoteidentitypublic(ArgT0&& arg0, ArgT... args);
  std::string* mutable_remoteidentitypublic();
  PROTOBUF_NODISCARD std::string* release_remoteidentitypublic();
  void set_allocated_remoteidentitypublic(std::string* remoteidentitypublic);
  private:
  const std::string& _internal_remoteidentitypublic() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_remoteidentitypublic(const std::string& value);
  std::string* _internal_mutable_remoteidentitypublic();
  public:

  // optional bytes rootKey = 4;
  bool has_rootkey() const;
  private:
  bool _internal_has_rootkey() const;
  public:
  void clear_rootkey();
  const std::string& rootkey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_rootkey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_rootkey();
  PROTOBUF_NODISCARD std::string* release_rootkey();
  void set_allocated_rootkey(std::string* rootkey);
  private:
  const std::string& _internal_rootkey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rootkey(const std::string& value);
  std::string* _internal_mutable_rootkey();
  public:

  // optional bytes aliceBaseKey = 13;
  bool has_alicebasekey() const;
  private:
  bool _internal_has_alicebasekey() const;
  public:
  void clear_alicebasekey();
  const std::string& alicebasekey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_alicebasekey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_alicebasekey();
  PROTOBUF_NODISCARD std::string* release_alicebasekey();
  void set_allocated_alicebasekey(std::string* alicebasekey);
  private:
  const std::string& _internal_alicebasekey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_alicebasekey(const std::string& value);
  std::string* _internal_mutable_alicebasekey();
  public:

  // optional .proto.Chain senderChain = 6;
  bool has_senderchain() const;
  private:
  bool _internal_has_senderchain() const;
  public:
  void clear_senderchain();
  const ::proto::Chain& senderchain() const;
  PROTOBUF_NODISCARD ::proto::Chain* release_senderchain();
  ::proto::Chain* mutable_senderchain();
  void set_allocated_senderchain(::proto::Chain* senderchain);
  private:
  const ::proto::Chain& _internal_senderchain() const;
  ::proto::Chain* _internal_mutable_senderchain();
  public:
  void unsafe_arena_set_allocated_senderchain(
      ::proto::Chain* senderchain);
  ::proto::Chain* unsafe_arena_release_senderchain();

  // optional .proto.PendingKeyExchange pendingKeyExchange = 8;
  bool has_pendingkeyexchange() const;
  private:
  bool _internal_has_pendingkeyexchange() const;
  public:
  void clear_pendingkeyexchange();
  const ::proto::PendingKeyExchange& pendingkeyexchange() const;
  PROTOBUF_NODISCARD ::proto::PendingKeyExchange* release_pendingkeyexchange();
  ::proto::PendingKeyExchange* mutable_pendingkeyexchange();
  void set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange);
  private:
  const ::proto::PendingKeyExchange& _internal_pendingkeyexchange() const;
  ::proto::PendingKeyExchange* _internal_mutable_pendingkeyexchange();
  public:
  void unsafe_arena_set_allocated_pendingkeyexchange(
      ::proto::PendingKeyExchange* pendingkeyexchange);
  ::proto::PendingKeyExchange* unsafe_arena_release_pendingkeyexchange();

  // optional .proto.PendingPreKey pendingPreKey = 9;
  bool has_pendingprekey() const;
  private:
  bool _internal_has_pendingprekey() const;
  public:
  void clear_pendingprekey();
  const ::proto::PendingPreKey& pendingprekey() const;
  PROTOBUF_NODISCARD ::proto::PendingPreKey* release_pendingprekey();
  ::proto::PendingPreKey* mutable_pendingprekey();
  void set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey);
  private:
  const ::proto::PendingPreKey& _internal_pendingprekey() const;
  ::proto::PendingPreKey* _internal_mutable_pendingprekey();
  public:
  void unsafe_arena_set_allocated_pendingprekey(
      ::proto::PendingPreKey* pendingprekey);
  ::proto::PendingPreKey* unsafe_arena_release_pendingprekey();

  // optional uint32 sessionVersion = 1;
  bool has_sessionversion() const;
  private:
  bool _internal_has_sessionversion() const;
  public:
  void clear_sessionversion();
  uint32_t sessionversion() const;
  void set_sessionversion(uint32_t value);
  private:
  uint32_t _internal_sessionversion() const;
  void _internal_set_sessionversion(uint32_t value);
  public:

  // optional uint32 previousCounter = 5;
  bool has_previouscounter() const;
  private:
  bool _internal_has_previouscounter() const;
  public:
  void clear_previouscounter();
  uint32_t previouscounter() const;
  void set_previouscounter(uint32_t value);
  private:
  uint32_t _internal_previouscounter() const;
  void _internal_set_previouscounter(uint32_t value);
  public:

  // optional uint32 remoteRegistrationId = 10;
  bool has_remoteregistrationid() const;
  private:
  bool _internal_has_remoteregistrationid() const;
  public:
  void clear_remoteregistrationid();
  uint32_t remoteregistrationid() const;
  void set_remoteregistrationid(uint32_t value);
  private:
  uint32_t _internal_remoteregistrationid() const;
  void _internal_set_remoteregistrationid(uint32_t value);
  public:

  // optional uint32 localRegistrationId = 11;
  bool has_localregistrationid() const;
  private:
  bool _internal_has_localregistrationid() const;
  public:
  void clear_localregistrationid();
  uint32_t localregistrationid() const;
  void set_localregistrationid(uint32_t value);
  private:
  uint32_t _internal_localregistrationid() const;
  void _internal_set_localregistrationid(uint32_t value);
  public:

  // optional bool needsRefresh = 12;
  bool has_needsrefresh() const;
  private:
  bool _internal_has_needsrefresh() const;
  public:
  void clear_needsrefresh();
  bool needsrefresh() const;
  void set_needsrefresh(bool value);
  private:
  bool _internal_needsrefresh() const;
  void _internal_set_needsrefresh(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SessionStructure)
 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< ::proto::Chain > receiverchains_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localidentitypublic_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr remoteidentitypublic_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rootkey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alicebasekey_;
    ::proto::Chain* senderchain_;
    ::proto::PendingKeyExchange* pendingkeyexchange_;
    ::proto::PendingPreKey* pendingprekey_;
    uint32_t sessionversion_;
    uint32_t previouscounter_;
    uint32_t remoteregistrationid_;
    uint32_t localregistrationid_;
    bool needsrefresh_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SignedPreKeyRecordStructure final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SignedPreKeyRecordStructure) */ {
 public:
  inline SignedPreKeyRecordStructure() : SignedPreKeyRecordStructure(nullptr) {}
  ~SignedPreKeyRecordStructure() override;
  explicit PROTOBUF_CONSTEXPR SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SignedPreKeyRecordStructure(const SignedPreKeyRecordStructure& from);
  SignedPreKeyRecordStructure(SignedPreKeyRecordStructure&& from) noexcept
    : SignedPreKeyRecordStructure() {
    *this = ::std::move(from);
  }

  inline SignedPreKeyRecordStructure& operator=(const SignedPreKeyRecordStructure& from) {
    CopyFrom(from);
    return *this;
  }
  inline SignedPreKeyRecordStructure& operator=(SignedPreKeyRecordStructure&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SignedPreKeyRecordStructure& default_instance() {
    return *internal_default_instance();
  }
  static inline const SignedPreKeyRecordStructure* internal_default_instance() {
    return reinterpret_cast<const SignedPreKeyRecordStructure*>(
               &_SignedPreKeyRecordStructure_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    171;

  friend void swap(SignedPreKeyRecordStructure& a, SignedPreKeyRecordStructure& b) {
    a.Swap(&b);
  }
  inline void Swap(SignedPreKeyRecordStructure* 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(SignedPreKeyRecordStructure* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SignedPreKeyRecordStructure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SignedPreKeyRecordStructure>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SignedPreKeyRecordStructure& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SignedPreKeyRecordStructure& from) {
    SignedPreKeyRecordStructure::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SignedPreKeyRecordStructure* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SignedPreKeyRecordStructure";
  }
  protected:
  explicit SignedPreKeyRecordStructure(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPublicKeyFieldNumber = 2,
    kPrivateKeyFieldNumber = 3,
    kSignatureFieldNumber = 4,
    kTimestampFieldNumber = 5,
    kIdFieldNumber = 1,
  };
  // optional bytes publicKey = 2;
  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:

  // optional bytes privateKey = 3;
  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:

  // optional bytes signature = 4;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_NODISCARD std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // optional fixed64 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 uint32 id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  uint32_t id() const;
  void set_id(uint32_t value);
  private:
  uint32_t _internal_id() const;
  void _internal_set_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SignedPreKeyRecordStructure)
 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 publickey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr privatekey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    uint64_t timestamp_;
    uint32_t id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class StatusPSA final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StatusPSA) */ {
 public:
  inline StatusPSA() : StatusPSA(nullptr) {}
  ~StatusPSA() override;
  explicit PROTOBUF_CONSTEXPR StatusPSA(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StatusPSA(const StatusPSA& from);
  StatusPSA(StatusPSA&& from) noexcept
    : StatusPSA() {
    *this = ::std::move(from);
  }

  inline StatusPSA& operator=(const StatusPSA& from) {
    CopyFrom(from);
    return *this;
  }
  inline StatusPSA& operator=(StatusPSA&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StatusPSA& default_instance() {
    return *internal_default_instance();
  }
  static inline const StatusPSA* internal_default_instance() {
    return reinterpret_cast<const StatusPSA*>(
               &_StatusPSA_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    172;

  friend void swap(StatusPSA& a, StatusPSA& b) {
    a.Swap(&b);
  }
  inline void Swap(StatusPSA* 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(StatusPSA* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  StatusPSA* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StatusPSA>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StatusPSA& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const StatusPSA& from) {
    StatusPSA::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StatusPSA* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.StatusPSA";
  }
  protected:
  explicit StatusPSA(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCampaignIdFieldNumber = 44,
    kCampaignExpirationTimestampFieldNumber = 45,
  };
  // required uint64 campaignId = 44;
  bool has_campaignid() const;
  private:
  bool _internal_has_campaignid() const;
  public:
  void clear_campaignid();
  uint64_t campaignid() const;
  void set_campaignid(uint64_t value);
  private:
  uint64_t _internal_campaignid() const;
  void _internal_set_campaignid(uint64_t value);
  public:

  // optional uint64 campaignExpirationTimestamp = 45;
  bool has_campaignexpirationtimestamp() const;
  private:
  bool _internal_has_campaignexpirationtimestamp() const;
  public:
  void clear_campaignexpirationtimestamp();
  uint64_t campaignexpirationtimestamp() const;
  void set_campaignexpirationtimestamp(uint64_t value);
  private:
  uint64_t _internal_campaignexpirationtimestamp() const;
  void _internal_set_campaignexpirationtimestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.StatusPSA)
 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 campaignid_;
    uint64_t campaignexpirationtimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class StickerMetadata final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.StickerMetadata) */ {
 public:
  inline StickerMetadata() : StickerMetadata(nullptr) {}
  ~StickerMetadata() override;
  explicit PROTOBUF_CONSTEXPR StickerMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StickerMetadata(const StickerMetadata& from);
  StickerMetadata(StickerMetadata&& from) noexcept
    : StickerMetadata() {
    *this = ::std::move(from);
  }

  inline StickerMetadata& operator=(const StickerMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline StickerMetadata& operator=(StickerMetadata&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StickerMetadata& default_instance() {
    return *internal_default_instance();
  }
  static inline const StickerMetadata* internal_default_instance() {
    return reinterpret_cast<const StickerMetadata*>(
               &_StickerMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    173;

  friend void swap(StickerMetadata& a, StickerMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(StickerMetadata* 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(StickerMetadata* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  StickerMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<StickerMetadata>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const StickerMetadata& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const StickerMetadata& from) {
    StickerMetadata::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StickerMetadata* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.StickerMetadata";
  }
  protected:
  explicit StickerMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUrlFieldNumber = 1,
    kFileSha256FieldNumber = 2,
    kFileEncSha256FieldNumber = 3,
    kMediaKeyFieldNumber = 4,
    kMimetypeFieldNumber = 5,
    kDirectPathFieldNumber = 8,
    kHeightFieldNumber = 6,
    kWidthFieldNumber = 7,
    kFileLengthFieldNumber = 9,
    kWeightFieldNumber = 10,
  };
  // optional 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 bytes fileSha256 = 2;
  bool has_filesha256() const;
  private:
  bool _internal_has_filesha256() const;
  public:
  void clear_filesha256();
  const std::string& filesha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_filesha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_filesha256();
  PROTOBUF_NODISCARD std::string* release_filesha256();
  void set_allocated_filesha256(std::string* filesha256);
  private:
  const std::string& _internal_filesha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_filesha256(const std::string& value);
  std::string* _internal_mutable_filesha256();
  public:

  // optional bytes fileEncSha256 = 3;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional bytes mediaKey = 4;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string mimetype = 5;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional string directPath = 8;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional uint32 height = 6;
  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:

  // optional uint32 width = 7;
  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 uint64 fileLength = 9;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional float weight = 10;
  bool has_weight() const;
  private:
  bool _internal_has_weight() const;
  public:
  void clear_weight();
  float weight() const;
  void set_weight(float value);
  private:
  float _internal_weight() const;
  void _internal_set_weight(float value);
  public:

  // @@protoc_insertion_point(class_scope:proto.StickerMetadata)
 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 filesha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    uint32_t height_;
    uint32_t width_;
    uint64_t filelength_;
    float weight_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionData final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionData) */ {
 public:
  inline SyncActionData() : SyncActionData(nullptr) {}
  ~SyncActionData() override;
  explicit PROTOBUF_CONSTEXPR SyncActionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionData(const SyncActionData& from);
  SyncActionData(SyncActionData&& from) noexcept
    : SyncActionData() {
    *this = ::std::move(from);
  }

  inline SyncActionData& operator=(const SyncActionData& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionData& operator=(SyncActionData&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionData& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionData* internal_default_instance() {
    return reinterpret_cast<const SyncActionData*>(
               &_SyncActionData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    174;

  friend void swap(SyncActionData& a, SyncActionData& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionData* 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(SyncActionData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionData& from) {
    SyncActionData::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionData";
  }
  protected:
  explicit SyncActionData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndexFieldNumber = 1,
    kPaddingFieldNumber = 3,
    kValueFieldNumber = 2,
    kVersionFieldNumber = 4,
  };
  // optional bytes index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  const std::string& index() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_index(ArgT0&& arg0, ArgT... args);
  std::string* mutable_index();
  PROTOBUF_NODISCARD std::string* release_index();
  void set_allocated_index(std::string* index);
  private:
  const std::string& _internal_index() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_index(const std::string& value);
  std::string* _internal_mutable_index();
  public:

  // optional bytes padding = 3;
  bool has_padding() const;
  private:
  bool _internal_has_padding() const;
  public:
  void clear_padding();
  const std::string& padding() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_padding(ArgT0&& arg0, ArgT... args);
  std::string* mutable_padding();
  PROTOBUF_NODISCARD std::string* release_padding();
  void set_allocated_padding(std::string* padding);
  private:
  const std::string& _internal_padding() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_padding(const std::string& value);
  std::string* _internal_mutable_padding();
  public:

  // optional .proto.SyncActionValue value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::proto::SyncActionValue& value() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue* release_value();
  ::proto::SyncActionValue* mutable_value();
  void set_allocated_value(::proto::SyncActionValue* value);
  private:
  const ::proto::SyncActionValue& _internal_value() const;
  ::proto::SyncActionValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::proto::SyncActionValue* value);
  ::proto::SyncActionValue* unsafe_arena_release_value();

  // optional int32 version = 4;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  int32_t version() const;
  void set_version(int32_t value);
  private:
  int32_t _internal_version() const;
  void _internal_set_version(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionData)
 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 index_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr padding_;
    ::proto::SyncActionValue* value_;
    int32_t version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_AgentAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AgentAction) */ {
 public:
  inline SyncActionValue_AgentAction() : SyncActionValue_AgentAction(nullptr) {}
  ~SyncActionValue_AgentAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_AgentAction(const SyncActionValue_AgentAction& from);
  SyncActionValue_AgentAction(SyncActionValue_AgentAction&& from) noexcept
    : SyncActionValue_AgentAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_AgentAction& operator=(const SyncActionValue_AgentAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_AgentAction& operator=(SyncActionValue_AgentAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_AgentAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_AgentAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_AgentAction*>(
               &_SyncActionValue_AgentAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    175;

  friend void swap(SyncActionValue_AgentAction& a, SyncActionValue_AgentAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_AgentAction* 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(SyncActionValue_AgentAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_AgentAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_AgentAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_AgentAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_AgentAction& from) {
    SyncActionValue_AgentAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_AgentAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.AgentAction";
  }
  protected:
  explicit SyncActionValue_AgentAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kDeviceIDFieldNumber = 2,
    kIsDeletedFieldNumber = 3,
  };
  // optional string name = 1;
  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:

  // optional int32 deviceID = 2;
  bool has_deviceid() const;
  private:
  bool _internal_has_deviceid() const;
  public:
  void clear_deviceid();
  int32_t deviceid() const;
  void set_deviceid(int32_t value);
  private:
  int32_t _internal_deviceid() const;
  void _internal_set_deviceid(int32_t value);
  public:

  // optional bool isDeleted = 3;
  bool has_isdeleted() const;
  private:
  bool _internal_has_isdeleted() const;
  public:
  void clear_isdeleted();
  bool isdeleted() const;
  void set_isdeleted(bool value);
  private:
  bool _internal_isdeleted() const;
  void _internal_set_isdeleted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AgentAction)
 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 name_;
    int32_t deviceid_;
    bool isdeleted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_AndroidUnsupportedActions final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.AndroidUnsupportedActions) */ {
 public:
  inline SyncActionValue_AndroidUnsupportedActions() : SyncActionValue_AndroidUnsupportedActions(nullptr) {}
  ~SyncActionValue_AndroidUnsupportedActions() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_AndroidUnsupportedActions(const SyncActionValue_AndroidUnsupportedActions& from);
  SyncActionValue_AndroidUnsupportedActions(SyncActionValue_AndroidUnsupportedActions&& from) noexcept
    : SyncActionValue_AndroidUnsupportedActions() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_AndroidUnsupportedActions& operator=(const SyncActionValue_AndroidUnsupportedActions& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_AndroidUnsupportedActions& operator=(SyncActionValue_AndroidUnsupportedActions&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_AndroidUnsupportedActions& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_AndroidUnsupportedActions* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_AndroidUnsupportedActions*>(
               &_SyncActionValue_AndroidUnsupportedActions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    176;

  friend void swap(SyncActionValue_AndroidUnsupportedActions& a, SyncActionValue_AndroidUnsupportedActions& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_AndroidUnsupportedActions* 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(SyncActionValue_AndroidUnsupportedActions* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_AndroidUnsupportedActions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_AndroidUnsupportedActions>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_AndroidUnsupportedActions& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_AndroidUnsupportedActions& from) {
    SyncActionValue_AndroidUnsupportedActions::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_AndroidUnsupportedActions* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.AndroidUnsupportedActions";
  }
  protected:
  explicit SyncActionValue_AndroidUnsupportedActions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAllowedFieldNumber = 1,
  };
  // optional bool allowed = 1;
  bool has_allowed() const;
  private:
  bool _internal_has_allowed() const;
  public:
  void clear_allowed();
  bool allowed() const;
  void set_allowed(bool value);
  private:
  bool _internal_allowed() const;
  void _internal_set_allowed(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.AndroidUnsupportedActions)
 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 allowed_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_ArchiveChatAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ArchiveChatAction) */ {
 public:
  inline SyncActionValue_ArchiveChatAction() : SyncActionValue_ArchiveChatAction(nullptr) {}
  ~SyncActionValue_ArchiveChatAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_ArchiveChatAction(const SyncActionValue_ArchiveChatAction& from);
  SyncActionValue_ArchiveChatAction(SyncActionValue_ArchiveChatAction&& from) noexcept
    : SyncActionValue_ArchiveChatAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_ArchiveChatAction& operator=(const SyncActionValue_ArchiveChatAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_ArchiveChatAction& operator=(SyncActionValue_ArchiveChatAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_ArchiveChatAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_ArchiveChatAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_ArchiveChatAction*>(
               &_SyncActionValue_ArchiveChatAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    177;

  friend void swap(SyncActionValue_ArchiveChatAction& a, SyncActionValue_ArchiveChatAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_ArchiveChatAction* 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(SyncActionValue_ArchiveChatAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_ArchiveChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_ArchiveChatAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_ArchiveChatAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_ArchiveChatAction& from) {
    SyncActionValue_ArchiveChatAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_ArchiveChatAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.ArchiveChatAction";
  }
  protected:
  explicit SyncActionValue_ArchiveChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageRangeFieldNumber = 2,
    kArchivedFieldNumber = 1,
  };
  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
  bool has_messagerange() const;
  private:
  bool _internal_has_messagerange() const;
  public:
  void clear_messagerange();
  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  private:
  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
  public:
  void unsafe_arena_set_allocated_messagerange(
      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();

  // optional bool archived = 1;
  bool has_archived() const;
  private:
  bool _internal_has_archived() const;
  public:
  void clear_archived();
  bool archived() const;
  void set_archived(bool value);
  private:
  bool _internal_archived() const;
  void _internal_set_archived(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ArchiveChatAction)
 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_;
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
    bool archived_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_ClearChatAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ClearChatAction) */ {
 public:
  inline SyncActionValue_ClearChatAction() : SyncActionValue_ClearChatAction(nullptr) {}
  ~SyncActionValue_ClearChatAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_ClearChatAction(const SyncActionValue_ClearChatAction& from);
  SyncActionValue_ClearChatAction(SyncActionValue_ClearChatAction&& from) noexcept
    : SyncActionValue_ClearChatAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_ClearChatAction& operator=(const SyncActionValue_ClearChatAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_ClearChatAction& operator=(SyncActionValue_ClearChatAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_ClearChatAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_ClearChatAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_ClearChatAction*>(
               &_SyncActionValue_ClearChatAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    178;

  friend void swap(SyncActionValue_ClearChatAction& a, SyncActionValue_ClearChatAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_ClearChatAction* 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(SyncActionValue_ClearChatAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_ClearChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_ClearChatAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_ClearChatAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_ClearChatAction& from) {
    SyncActionValue_ClearChatAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_ClearChatAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.ClearChatAction";
  }
  protected:
  explicit SyncActionValue_ClearChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageRangeFieldNumber = 1,
  };
  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
  bool has_messagerange() const;
  private:
  bool _internal_has_messagerange() const;
  public:
  void clear_messagerange();
  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  private:
  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
  public:
  void unsafe_arena_set_allocated_messagerange(
      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ClearChatAction)
 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_;
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_ContactAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.ContactAction) */ {
 public:
  inline SyncActionValue_ContactAction() : SyncActionValue_ContactAction(nullptr) {}
  ~SyncActionValue_ContactAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_ContactAction(const SyncActionValue_ContactAction& from);
  SyncActionValue_ContactAction(SyncActionValue_ContactAction&& from) noexcept
    : SyncActionValue_ContactAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_ContactAction& operator=(const SyncActionValue_ContactAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_ContactAction& operator=(SyncActionValue_ContactAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_ContactAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_ContactAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_ContactAction*>(
               &_SyncActionValue_ContactAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    179;

  friend void swap(SyncActionValue_ContactAction& a, SyncActionValue_ContactAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_ContactAction* 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(SyncActionValue_ContactAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_ContactAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_ContactAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_ContactAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_ContactAction& from) {
    SyncActionValue_ContactAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_ContactAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.ContactAction";
  }
  protected:
  explicit SyncActionValue_ContactAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFullNameFieldNumber = 1,
    kFirstNameFieldNumber = 2,
  };
  // optional string fullName = 1;
  bool has_fullname() const;
  private:
  bool _internal_has_fullname() const;
  public:
  void clear_fullname();
  const std::string& fullname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fullname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fullname();
  PROTOBUF_NODISCARD std::string* release_fullname();
  void set_allocated_fullname(std::string* fullname);
  private:
  const std::string& _internal_fullname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fullname(const std::string& value);
  std::string* _internal_mutable_fullname();
  public:

  // optional string firstName = 2;
  bool has_firstname() const;
  private:
  bool _internal_has_firstname() const;
  public:
  void clear_firstname();
  const std::string& firstname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_firstname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_firstname();
  PROTOBUF_NODISCARD std::string* release_firstname();
  void set_allocated_firstname(std::string* firstname);
  private:
  const std::string& _internal_firstname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_firstname(const std::string& value);
  std::string* _internal_mutable_firstname();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.ContactAction)
 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 fullname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr firstname_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_DeleteChatAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteChatAction) */ {
 public:
  inline SyncActionValue_DeleteChatAction() : SyncActionValue_DeleteChatAction(nullptr) {}
  ~SyncActionValue_DeleteChatAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_DeleteChatAction(const SyncActionValue_DeleteChatAction& from);
  SyncActionValue_DeleteChatAction(SyncActionValue_DeleteChatAction&& from) noexcept
    : SyncActionValue_DeleteChatAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_DeleteChatAction& operator=(const SyncActionValue_DeleteChatAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_DeleteChatAction& operator=(SyncActionValue_DeleteChatAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_DeleteChatAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_DeleteChatAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_DeleteChatAction*>(
               &_SyncActionValue_DeleteChatAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    180;

  friend void swap(SyncActionValue_DeleteChatAction& a, SyncActionValue_DeleteChatAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_DeleteChatAction* 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(SyncActionValue_DeleteChatAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_DeleteChatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_DeleteChatAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_DeleteChatAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_DeleteChatAction& from) {
    SyncActionValue_DeleteChatAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_DeleteChatAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.DeleteChatAction";
  }
  protected:
  explicit SyncActionValue_DeleteChatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageRangeFieldNumber = 1,
  };
  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
  bool has_messagerange() const;
  private:
  bool _internal_has_messagerange() const;
  public:
  void clear_messagerange();
  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  private:
  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
  public:
  void unsafe_arena_set_allocated_messagerange(
      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteChatAction)
 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_;
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_DeleteMessageForMeAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.DeleteMessageForMeAction) */ {
 public:
  inline SyncActionValue_DeleteMessageForMeAction() : SyncActionValue_DeleteMessageForMeAction(nullptr) {}
  ~SyncActionValue_DeleteMessageForMeAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_DeleteMessageForMeAction(const SyncActionValue_DeleteMessageForMeAction& from);
  SyncActionValue_DeleteMessageForMeAction(SyncActionValue_DeleteMessageForMeAction&& from) noexcept
    : SyncActionValue_DeleteMessageForMeAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_DeleteMessageForMeAction& operator=(const SyncActionValue_DeleteMessageForMeAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_DeleteMessageForMeAction& operator=(SyncActionValue_DeleteMessageForMeAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_DeleteMessageForMeAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_DeleteMessageForMeAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_DeleteMessageForMeAction*>(
               &_SyncActionValue_DeleteMessageForMeAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    181;

  friend void swap(SyncActionValue_DeleteMessageForMeAction& a, SyncActionValue_DeleteMessageForMeAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_DeleteMessageForMeAction* 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(SyncActionValue_DeleteMessageForMeAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_DeleteMessageForMeAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_DeleteMessageForMeAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_DeleteMessageForMeAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_DeleteMessageForMeAction& from) {
    SyncActionValue_DeleteMessageForMeAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_DeleteMessageForMeAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.DeleteMessageForMeAction";
  }
  protected:
  explicit SyncActionValue_DeleteMessageForMeAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageTimestampFieldNumber = 2,
    kDeleteMediaFieldNumber = 1,
  };
  // optional int64 messageTimestamp = 2;
  bool has_messagetimestamp() const;
  private:
  bool _internal_has_messagetimestamp() const;
  public:
  void clear_messagetimestamp();
  int64_t messagetimestamp() const;
  void set_messagetimestamp(int64_t value);
  private:
  int64_t _internal_messagetimestamp() const;
  void _internal_set_messagetimestamp(int64_t value);
  public:

  // optional bool deleteMedia = 1;
  bool has_deletemedia() const;
  private:
  bool _internal_has_deletemedia() const;
  public:
  void clear_deletemedia();
  bool deletemedia() const;
  void set_deletemedia(bool value);
  private:
  bool _internal_deletemedia() const;
  void _internal_set_deletemedia(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.DeleteMessageForMeAction)
 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_;
    int64_t messagetimestamp_;
    bool deletemedia_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_KeyExpiration final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.KeyExpiration) */ {
 public:
  inline SyncActionValue_KeyExpiration() : SyncActionValue_KeyExpiration(nullptr) {}
  ~SyncActionValue_KeyExpiration() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_KeyExpiration(const SyncActionValue_KeyExpiration& from);
  SyncActionValue_KeyExpiration(SyncActionValue_KeyExpiration&& from) noexcept
    : SyncActionValue_KeyExpiration() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_KeyExpiration& operator=(const SyncActionValue_KeyExpiration& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_KeyExpiration& operator=(SyncActionValue_KeyExpiration&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_KeyExpiration& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_KeyExpiration* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_KeyExpiration*>(
               &_SyncActionValue_KeyExpiration_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    182;

  friend void swap(SyncActionValue_KeyExpiration& a, SyncActionValue_KeyExpiration& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_KeyExpiration* 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(SyncActionValue_KeyExpiration* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_KeyExpiration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_KeyExpiration>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_KeyExpiration& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_KeyExpiration& from) {
    SyncActionValue_KeyExpiration::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_KeyExpiration* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.KeyExpiration";
  }
  protected:
  explicit SyncActionValue_KeyExpiration(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExpiredKeyEpochFieldNumber = 1,
  };
  // optional int32 expiredKeyEpoch = 1;
  bool has_expiredkeyepoch() const;
  private:
  bool _internal_has_expiredkeyepoch() const;
  public:
  void clear_expiredkeyepoch();
  int32_t expiredkeyepoch() const;
  void set_expiredkeyepoch(int32_t value);
  private:
  int32_t _internal_expiredkeyepoch() const;
  void _internal_set_expiredkeyepoch(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.KeyExpiration)
 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_;
    int32_t expiredkeyepoch_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_LabelAssociationAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelAssociationAction) */ {
 public:
  inline SyncActionValue_LabelAssociationAction() : SyncActionValue_LabelAssociationAction(nullptr) {}
  ~SyncActionValue_LabelAssociationAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_LabelAssociationAction(const SyncActionValue_LabelAssociationAction& from);
  SyncActionValue_LabelAssociationAction(SyncActionValue_LabelAssociationAction&& from) noexcept
    : SyncActionValue_LabelAssociationAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_LabelAssociationAction& operator=(const SyncActionValue_LabelAssociationAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_LabelAssociationAction& operator=(SyncActionValue_LabelAssociationAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_LabelAssociationAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_LabelAssociationAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_LabelAssociationAction*>(
               &_SyncActionValue_LabelAssociationAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    183;

  friend void swap(SyncActionValue_LabelAssociationAction& a, SyncActionValue_LabelAssociationAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_LabelAssociationAction* 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(SyncActionValue_LabelAssociationAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_LabelAssociationAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_LabelAssociationAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_LabelAssociationAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_LabelAssociationAction& from) {
    SyncActionValue_LabelAssociationAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_LabelAssociationAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.LabelAssociationAction";
  }
  protected:
  explicit SyncActionValue_LabelAssociationAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLabeledFieldNumber = 1,
  };
  // optional bool labeled = 1;
  bool has_labeled() const;
  private:
  bool _internal_has_labeled() const;
  public:
  void clear_labeled();
  bool labeled() const;
  void set_labeled(bool value);
  private:
  bool _internal_labeled() const;
  void _internal_set_labeled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelAssociationAction)
 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 labeled_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_LabelEditAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LabelEditAction) */ {
 public:
  inline SyncActionValue_LabelEditAction() : SyncActionValue_LabelEditAction(nullptr) {}
  ~SyncActionValue_LabelEditAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_LabelEditAction(const SyncActionValue_LabelEditAction& from);
  SyncActionValue_LabelEditAction(SyncActionValue_LabelEditAction&& from) noexcept
    : SyncActionValue_LabelEditAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_LabelEditAction& operator=(const SyncActionValue_LabelEditAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_LabelEditAction& operator=(SyncActionValue_LabelEditAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_LabelEditAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_LabelEditAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_LabelEditAction*>(
               &_SyncActionValue_LabelEditAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    184;

  friend void swap(SyncActionValue_LabelEditAction& a, SyncActionValue_LabelEditAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_LabelEditAction* 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(SyncActionValue_LabelEditAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_LabelEditAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_LabelEditAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_LabelEditAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_LabelEditAction& from) {
    SyncActionValue_LabelEditAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_LabelEditAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.LabelEditAction";
  }
  protected:
  explicit SyncActionValue_LabelEditAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kColorFieldNumber = 2,
    kPredefinedIdFieldNumber = 3,
    kDeletedFieldNumber = 4,
  };
  // optional string name = 1;
  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:

  // optional int32 color = 2;
  bool has_color() const;
  private:
  bool _internal_has_color() const;
  public:
  void clear_color();
  int32_t color() const;
  void set_color(int32_t value);
  private:
  int32_t _internal_color() const;
  void _internal_set_color(int32_t value);
  public:

  // optional int32 predefinedId = 3;
  bool has_predefinedid() const;
  private:
  bool _internal_has_predefinedid() const;
  public:
  void clear_predefinedid();
  int32_t predefinedid() const;
  void set_predefinedid(int32_t value);
  private:
  int32_t _internal_predefinedid() const;
  void _internal_set_predefinedid(int32_t value);
  public:

  // optional bool deleted = 4;
  bool has_deleted() const;
  private:
  bool _internal_has_deleted() const;
  public:
  void clear_deleted();
  bool deleted() const;
  void set_deleted(bool value);
  private:
  bool _internal_deleted() const;
  void _internal_set_deleted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LabelEditAction)
 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 name_;
    int32_t color_;
    int32_t predefinedid_;
    bool deleted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_LocaleSetting final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.LocaleSetting) */ {
 public:
  inline SyncActionValue_LocaleSetting() : SyncActionValue_LocaleSetting(nullptr) {}
  ~SyncActionValue_LocaleSetting() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_LocaleSetting(const SyncActionValue_LocaleSetting& from);
  SyncActionValue_LocaleSetting(SyncActionValue_LocaleSetting&& from) noexcept
    : SyncActionValue_LocaleSetting() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_LocaleSetting& operator=(const SyncActionValue_LocaleSetting& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_LocaleSetting& operator=(SyncActionValue_LocaleSetting&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_LocaleSetting& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_LocaleSetting* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_LocaleSetting*>(
               &_SyncActionValue_LocaleSetting_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    185;

  friend void swap(SyncActionValue_LocaleSetting& a, SyncActionValue_LocaleSetting& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_LocaleSetting* 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(SyncActionValue_LocaleSetting* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_LocaleSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_LocaleSetting>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_LocaleSetting& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_LocaleSetting& from) {
    SyncActionValue_LocaleSetting::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_LocaleSetting* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.LocaleSetting";
  }
  protected:
  explicit SyncActionValue_LocaleSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLocaleFieldNumber = 1,
  };
  // optional string locale = 1;
  bool has_locale() const;
  private:
  bool _internal_has_locale() const;
  public:
  void clear_locale();
  const std::string& locale() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_locale(ArgT0&& arg0, ArgT... args);
  std::string* mutable_locale();
  PROTOBUF_NODISCARD std::string* release_locale();
  void set_allocated_locale(std::string* locale);
  private:
  const std::string& _internal_locale() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_locale(const std::string& value);
  std::string* _internal_mutable_locale();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.LocaleSetting)
 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 locale_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_MarkChatAsReadAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MarkChatAsReadAction) */ {
 public:
  inline SyncActionValue_MarkChatAsReadAction() : SyncActionValue_MarkChatAsReadAction(nullptr) {}
  ~SyncActionValue_MarkChatAsReadAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_MarkChatAsReadAction(const SyncActionValue_MarkChatAsReadAction& from);
  SyncActionValue_MarkChatAsReadAction(SyncActionValue_MarkChatAsReadAction&& from) noexcept
    : SyncActionValue_MarkChatAsReadAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_MarkChatAsReadAction& operator=(const SyncActionValue_MarkChatAsReadAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_MarkChatAsReadAction& operator=(SyncActionValue_MarkChatAsReadAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_MarkChatAsReadAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_MarkChatAsReadAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_MarkChatAsReadAction*>(
               &_SyncActionValue_MarkChatAsReadAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    186;

  friend void swap(SyncActionValue_MarkChatAsReadAction& a, SyncActionValue_MarkChatAsReadAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_MarkChatAsReadAction* 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(SyncActionValue_MarkChatAsReadAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_MarkChatAsReadAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_MarkChatAsReadAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_MarkChatAsReadAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_MarkChatAsReadAction& from) {
    SyncActionValue_MarkChatAsReadAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_MarkChatAsReadAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.MarkChatAsReadAction";
  }
  protected:
  explicit SyncActionValue_MarkChatAsReadAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessageRangeFieldNumber = 2,
    kReadFieldNumber = 1,
  };
  // optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
  bool has_messagerange() const;
  private:
  bool _internal_has_messagerange() const;
  public:
  void clear_messagerange();
  const ::proto::SyncActionValue_SyncActionMessageRange& messagerange() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SyncActionMessageRange* release_messagerange();
  ::proto::SyncActionValue_SyncActionMessageRange* mutable_messagerange();
  void set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  private:
  const ::proto::SyncActionValue_SyncActionMessageRange& _internal_messagerange() const;
  ::proto::SyncActionValue_SyncActionMessageRange* _internal_mutable_messagerange();
  public:
  void unsafe_arena_set_allocated_messagerange(
      ::proto::SyncActionValue_SyncActionMessageRange* messagerange);
  ::proto::SyncActionValue_SyncActionMessageRange* unsafe_arena_release_messagerange();

  // optional bool read = 1;
  bool has_read() const;
  private:
  bool _internal_has_read() const;
  public:
  void clear_read();
  bool read() const;
  void set_read(bool value);
  private:
  bool _internal_read() const;
  void _internal_set_read(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MarkChatAsReadAction)
 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_;
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange_;
    bool read_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_MuteAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.MuteAction) */ {
 public:
  inline SyncActionValue_MuteAction() : SyncActionValue_MuteAction(nullptr) {}
  ~SyncActionValue_MuteAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_MuteAction(const SyncActionValue_MuteAction& from);
  SyncActionValue_MuteAction(SyncActionValue_MuteAction&& from) noexcept
    : SyncActionValue_MuteAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_MuteAction& operator=(const SyncActionValue_MuteAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_MuteAction& operator=(SyncActionValue_MuteAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_MuteAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_MuteAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_MuteAction*>(
               &_SyncActionValue_MuteAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    187;

  friend void swap(SyncActionValue_MuteAction& a, SyncActionValue_MuteAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_MuteAction* 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(SyncActionValue_MuteAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_MuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_MuteAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_MuteAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_MuteAction& from) {
    SyncActionValue_MuteAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_MuteAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.MuteAction";
  }
  protected:
  explicit SyncActionValue_MuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMuteEndTimestampFieldNumber = 2,
    kMutedFieldNumber = 1,
  };
  // optional int64 muteEndTimestamp = 2;
  bool has_muteendtimestamp() const;
  private:
  bool _internal_has_muteendtimestamp() const;
  public:
  void clear_muteendtimestamp();
  int64_t muteendtimestamp() const;
  void set_muteendtimestamp(int64_t value);
  private:
  int64_t _internal_muteendtimestamp() const;
  void _internal_set_muteendtimestamp(int64_t value);
  public:

  // optional bool muted = 1;
  bool has_muted() const;
  private:
  bool _internal_has_muted() const;
  public:
  void clear_muted();
  bool muted() const;
  void set_muted(bool value);
  private:
  bool _internal_muted() const;
  void _internal_set_muted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.MuteAction)
 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_;
    int64_t muteendtimestamp_;
    bool muted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_NuxAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.NuxAction) */ {
 public:
  inline SyncActionValue_NuxAction() : SyncActionValue_NuxAction(nullptr) {}
  ~SyncActionValue_NuxAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_NuxAction(const SyncActionValue_NuxAction& from);
  SyncActionValue_NuxAction(SyncActionValue_NuxAction&& from) noexcept
    : SyncActionValue_NuxAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_NuxAction& operator=(const SyncActionValue_NuxAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_NuxAction& operator=(SyncActionValue_NuxAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_NuxAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_NuxAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_NuxAction*>(
               &_SyncActionValue_NuxAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    188;

  friend void swap(SyncActionValue_NuxAction& a, SyncActionValue_NuxAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_NuxAction* 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(SyncActionValue_NuxAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_NuxAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_NuxAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_NuxAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_NuxAction& from) {
    SyncActionValue_NuxAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_NuxAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.NuxAction";
  }
  protected:
  explicit SyncActionValue_NuxAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kAcknowledgedFieldNumber = 1,
  };
  // optional bool acknowledged = 1;
  bool has_acknowledged() const;
  private:
  bool _internal_has_acknowledged() const;
  public:
  void clear_acknowledged();
  bool acknowledged() const;
  void set_acknowledged(bool value);
  private:
  bool _internal_acknowledged() const;
  void _internal_set_acknowledged(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.NuxAction)
 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 acknowledged_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_PinAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PinAction) */ {
 public:
  inline SyncActionValue_PinAction() : SyncActionValue_PinAction(nullptr) {}
  ~SyncActionValue_PinAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_PinAction(const SyncActionValue_PinAction& from);
  SyncActionValue_PinAction(SyncActionValue_PinAction&& from) noexcept
    : SyncActionValue_PinAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_PinAction& operator=(const SyncActionValue_PinAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_PinAction& operator=(SyncActionValue_PinAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_PinAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_PinAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_PinAction*>(
               &_SyncActionValue_PinAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    189;

  friend void swap(SyncActionValue_PinAction& a, SyncActionValue_PinAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_PinAction* 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(SyncActionValue_PinAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_PinAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_PinAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_PinAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_PinAction& from) {
    SyncActionValue_PinAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_PinAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.PinAction";
  }
  protected:
  explicit SyncActionValue_PinAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPinnedFieldNumber = 1,
  };
  // optional bool pinned = 1;
  bool has_pinned() const;
  private:
  bool _internal_has_pinned() const;
  public:
  void clear_pinned();
  bool pinned() const;
  void set_pinned(bool value);
  private:
  bool _internal_pinned() const;
  void _internal_set_pinned(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PinAction)
 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 pinned_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_PrimaryFeature final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryFeature) */ {
 public:
  inline SyncActionValue_PrimaryFeature() : SyncActionValue_PrimaryFeature(nullptr) {}
  ~SyncActionValue_PrimaryFeature() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_PrimaryFeature(const SyncActionValue_PrimaryFeature& from);
  SyncActionValue_PrimaryFeature(SyncActionValue_PrimaryFeature&& from) noexcept
    : SyncActionValue_PrimaryFeature() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_PrimaryFeature& operator=(const SyncActionValue_PrimaryFeature& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_PrimaryFeature& operator=(SyncActionValue_PrimaryFeature&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_PrimaryFeature& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_PrimaryFeature* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_PrimaryFeature*>(
               &_SyncActionValue_PrimaryFeature_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    190;

  friend void swap(SyncActionValue_PrimaryFeature& a, SyncActionValue_PrimaryFeature& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_PrimaryFeature* 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(SyncActionValue_PrimaryFeature* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_PrimaryFeature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_PrimaryFeature>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_PrimaryFeature& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_PrimaryFeature& from) {
    SyncActionValue_PrimaryFeature::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_PrimaryFeature* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.PrimaryFeature";
  }
  protected:
  explicit SyncActionValue_PrimaryFeature(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFlagsFieldNumber = 1,
  };
  // repeated string flags = 1;
  int flags_size() const;
  private:
  int _internal_flags_size() const;
  public:
  void clear_flags();
  const std::string& flags(int index) const;
  std::string* mutable_flags(int index);
  void set_flags(int index, const std::string& value);
  void set_flags(int index, std::string&& value);
  void set_flags(int index, const char* value);
  void set_flags(int index, const char* value, size_t size);
  std::string* add_flags();
  void add_flags(const std::string& value);
  void add_flags(std::string&& value);
  void add_flags(const char* value);
  void add_flags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& flags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_flags();
  private:
  const std::string& _internal_flags(int index) const;
  std::string* _internal_add_flags();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryFeature)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> flags_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_PrimaryVersionAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PrimaryVersionAction) */ {
 public:
  inline SyncActionValue_PrimaryVersionAction() : SyncActionValue_PrimaryVersionAction(nullptr) {}
  ~SyncActionValue_PrimaryVersionAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_PrimaryVersionAction(const SyncActionValue_PrimaryVersionAction& from);
  SyncActionValue_PrimaryVersionAction(SyncActionValue_PrimaryVersionAction&& from) noexcept
    : SyncActionValue_PrimaryVersionAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_PrimaryVersionAction& operator=(const SyncActionValue_PrimaryVersionAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_PrimaryVersionAction& operator=(SyncActionValue_PrimaryVersionAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_PrimaryVersionAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_PrimaryVersionAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_PrimaryVersionAction*>(
               &_SyncActionValue_PrimaryVersionAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    191;

  friend void swap(SyncActionValue_PrimaryVersionAction& a, SyncActionValue_PrimaryVersionAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_PrimaryVersionAction* 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(SyncActionValue_PrimaryVersionAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_PrimaryVersionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_PrimaryVersionAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_PrimaryVersionAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_PrimaryVersionAction& from) {
    SyncActionValue_PrimaryVersionAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_PrimaryVersionAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.PrimaryVersionAction";
  }
  protected:
  explicit SyncActionValue_PrimaryVersionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVersionFieldNumber = 1,
  };
  // optional string version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const std::string& version() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_version(ArgT0&& arg0, ArgT... args);
  std::string* mutable_version();
  PROTOBUF_NODISCARD std::string* release_version();
  void set_allocated_version(std::string* version);
  private:
  const std::string& _internal_version() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
  std::string* _internal_mutable_version();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.PrimaryVersionAction)
 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 version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_PushNameSetting final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.PushNameSetting) */ {
 public:
  inline SyncActionValue_PushNameSetting() : SyncActionValue_PushNameSetting(nullptr) {}
  ~SyncActionValue_PushNameSetting() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_PushNameSetting(const SyncActionValue_PushNameSetting& from);
  SyncActionValue_PushNameSetting(SyncActionValue_PushNameSetting&& from) noexcept
    : SyncActionValue_PushNameSetting() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_PushNameSetting& operator=(const SyncActionValue_PushNameSetting& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_PushNameSetting& operator=(SyncActionValue_PushNameSetting&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_PushNameSetting& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_PushNameSetting* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_PushNameSetting*>(
               &_SyncActionValue_PushNameSetting_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    192;

  friend void swap(SyncActionValue_PushNameSetting& a, SyncActionValue_PushNameSetting& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_PushNameSetting* 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(SyncActionValue_PushNameSetting* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_PushNameSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_PushNameSetting>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_PushNameSetting& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_PushNameSetting& from) {
    SyncActionValue_PushNameSetting::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_PushNameSetting* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.PushNameSetting";
  }
  protected:
  explicit SyncActionValue_PushNameSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
  };
  // optional string name = 1;
  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:proto.SyncActionValue.PushNameSetting)
 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 name_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_QuickReplyAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.QuickReplyAction) */ {
 public:
  inline SyncActionValue_QuickReplyAction() : SyncActionValue_QuickReplyAction(nullptr) {}
  ~SyncActionValue_QuickReplyAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_QuickReplyAction(const SyncActionValue_QuickReplyAction& from);
  SyncActionValue_QuickReplyAction(SyncActionValue_QuickReplyAction&& from) noexcept
    : SyncActionValue_QuickReplyAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_QuickReplyAction& operator=(const SyncActionValue_QuickReplyAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_QuickReplyAction& operator=(SyncActionValue_QuickReplyAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_QuickReplyAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_QuickReplyAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_QuickReplyAction*>(
               &_SyncActionValue_QuickReplyAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    193;

  friend void swap(SyncActionValue_QuickReplyAction& a, SyncActionValue_QuickReplyAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_QuickReplyAction* 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(SyncActionValue_QuickReplyAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_QuickReplyAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_QuickReplyAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_QuickReplyAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_QuickReplyAction& from) {
    SyncActionValue_QuickReplyAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_QuickReplyAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.QuickReplyAction";
  }
  protected:
  explicit SyncActionValue_QuickReplyAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeywordsFieldNumber = 3,
    kShortcutFieldNumber = 1,
    kMessageFieldNumber = 2,
    kCountFieldNumber = 4,
    kDeletedFieldNumber = 5,
  };
  // repeated string keywords = 3;
  int keywords_size() const;
  private:
  int _internal_keywords_size() const;
  public:
  void clear_keywords();
  const std::string& keywords(int index) const;
  std::string* mutable_keywords(int index);
  void set_keywords(int index, const std::string& value);
  void set_keywords(int index, std::string&& value);
  void set_keywords(int index, const char* value);
  void set_keywords(int index, const char* value, size_t size);
  std::string* add_keywords();
  void add_keywords(const std::string& value);
  void add_keywords(std::string&& value);
  void add_keywords(const char* value);
  void add_keywords(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& keywords() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_keywords();
  private:
  const std::string& _internal_keywords(int index) const;
  std::string* _internal_add_keywords();
  public:

  // optional string shortcut = 1;
  bool has_shortcut() const;
  private:
  bool _internal_has_shortcut() const;
  public:
  void clear_shortcut();
  const std::string& shortcut() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_shortcut(ArgT0&& arg0, ArgT... args);
  std::string* mutable_shortcut();
  PROTOBUF_NODISCARD std::string* release_shortcut();
  void set_allocated_shortcut(std::string* shortcut);
  private:
  const std::string& _internal_shortcut() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_shortcut(const std::string& value);
  std::string* _internal_mutable_shortcut();
  public:

  // optional string message = 2;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // optional int32 count = 4;
  bool has_count() const;
  private:
  bool _internal_has_count() const;
  public:
  void clear_count();
  int32_t count() const;
  void set_count(int32_t value);
  private:
  int32_t _internal_count() const;
  void _internal_set_count(int32_t value);
  public:

  // optional bool deleted = 5;
  bool has_deleted() const;
  private:
  bool _internal_has_deleted() const;
  public:
  void clear_deleted();
  bool deleted() const;
  void set_deleted(bool value);
  private:
  bool _internal_deleted() const;
  void _internal_set_deleted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.QuickReplyAction)
 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> keywords_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortcut_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
    int32_t count_;
    bool deleted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_RecentEmojiWeightsAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.RecentEmojiWeightsAction) */ {
 public:
  inline SyncActionValue_RecentEmojiWeightsAction() : SyncActionValue_RecentEmojiWeightsAction(nullptr) {}
  ~SyncActionValue_RecentEmojiWeightsAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_RecentEmojiWeightsAction(const SyncActionValue_RecentEmojiWeightsAction& from);
  SyncActionValue_RecentEmojiWeightsAction(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept
    : SyncActionValue_RecentEmojiWeightsAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_RecentEmojiWeightsAction& operator=(const SyncActionValue_RecentEmojiWeightsAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_RecentEmojiWeightsAction& operator=(SyncActionValue_RecentEmojiWeightsAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_RecentEmojiWeightsAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_RecentEmojiWeightsAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_RecentEmojiWeightsAction*>(
               &_SyncActionValue_RecentEmojiWeightsAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    194;

  friend void swap(SyncActionValue_RecentEmojiWeightsAction& a, SyncActionValue_RecentEmojiWeightsAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_RecentEmojiWeightsAction* 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(SyncActionValue_RecentEmojiWeightsAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_RecentEmojiWeightsAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_RecentEmojiWeightsAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_RecentEmojiWeightsAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_RecentEmojiWeightsAction& from) {
    SyncActionValue_RecentEmojiWeightsAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_RecentEmojiWeightsAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.RecentEmojiWeightsAction";
  }
  protected:
  explicit SyncActionValue_RecentEmojiWeightsAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWeightsFieldNumber = 1,
  };
  // repeated .proto.RecentEmojiWeight weights = 1;
  int weights_size() const;
  private:
  int _internal_weights_size() const;
  public:
  void clear_weights();
  ::proto::RecentEmojiWeight* mutable_weights(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >*
      mutable_weights();
  private:
  const ::proto::RecentEmojiWeight& _internal_weights(int index) const;
  ::proto::RecentEmojiWeight* _internal_add_weights();
  public:
  const ::proto::RecentEmojiWeight& weights(int index) const;
  ::proto::RecentEmojiWeight* add_weights();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >&
      weights() const;

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.RecentEmojiWeightsAction)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight > weights_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_SecurityNotificationSetting final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SecurityNotificationSetting) */ {
 public:
  inline SyncActionValue_SecurityNotificationSetting() : SyncActionValue_SecurityNotificationSetting(nullptr) {}
  ~SyncActionValue_SecurityNotificationSetting() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_SecurityNotificationSetting(const SyncActionValue_SecurityNotificationSetting& from);
  SyncActionValue_SecurityNotificationSetting(SyncActionValue_SecurityNotificationSetting&& from) noexcept
    : SyncActionValue_SecurityNotificationSetting() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_SecurityNotificationSetting& operator=(const SyncActionValue_SecurityNotificationSetting& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_SecurityNotificationSetting& operator=(SyncActionValue_SecurityNotificationSetting&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_SecurityNotificationSetting& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_SecurityNotificationSetting* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_SecurityNotificationSetting*>(
               &_SyncActionValue_SecurityNotificationSetting_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    195;

  friend void swap(SyncActionValue_SecurityNotificationSetting& a, SyncActionValue_SecurityNotificationSetting& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_SecurityNotificationSetting* 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(SyncActionValue_SecurityNotificationSetting* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_SecurityNotificationSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_SecurityNotificationSetting>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_SecurityNotificationSetting& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_SecurityNotificationSetting& from) {
    SyncActionValue_SecurityNotificationSetting::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_SecurityNotificationSetting* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.SecurityNotificationSetting";
  }
  protected:
  explicit SyncActionValue_SecurityNotificationSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kShowNotificationFieldNumber = 1,
  };
  // optional bool showNotification = 1;
  bool has_shownotification() const;
  private:
  bool _internal_has_shownotification() const;
  public:
  void clear_shownotification();
  bool shownotification() const;
  void set_shownotification(bool value);
  private:
  bool _internal_shownotification() const;
  void _internal_set_shownotification(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SecurityNotificationSetting)
 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 shownotification_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_StarAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StarAction) */ {
 public:
  inline SyncActionValue_StarAction() : SyncActionValue_StarAction(nullptr) {}
  ~SyncActionValue_StarAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_StarAction(const SyncActionValue_StarAction& from);
  SyncActionValue_StarAction(SyncActionValue_StarAction&& from) noexcept
    : SyncActionValue_StarAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_StarAction& operator=(const SyncActionValue_StarAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_StarAction& operator=(SyncActionValue_StarAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_StarAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_StarAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_StarAction*>(
               &_SyncActionValue_StarAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    196;

  friend void swap(SyncActionValue_StarAction& a, SyncActionValue_StarAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_StarAction* 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(SyncActionValue_StarAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_StarAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_StarAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_StarAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_StarAction& from) {
    SyncActionValue_StarAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_StarAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.StarAction";
  }
  protected:
  explicit SyncActionValue_StarAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kStarredFieldNumber = 1,
  };
  // optional bool starred = 1;
  bool has_starred() const;
  private:
  bool _internal_has_starred() const;
  public:
  void clear_starred();
  bool starred() const;
  void set_starred(bool value);
  private:
  bool _internal_starred() const;
  void _internal_set_starred(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StarAction)
 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 starred_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_StickerAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.StickerAction) */ {
 public:
  inline SyncActionValue_StickerAction() : SyncActionValue_StickerAction(nullptr) {}
  ~SyncActionValue_StickerAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_StickerAction(const SyncActionValue_StickerAction& from);
  SyncActionValue_StickerAction(SyncActionValue_StickerAction&& from) noexcept
    : SyncActionValue_StickerAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_StickerAction& operator=(const SyncActionValue_StickerAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_StickerAction& operator=(SyncActionValue_StickerAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_StickerAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_StickerAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_StickerAction*>(
               &_SyncActionValue_StickerAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    197;

  friend void swap(SyncActionValue_StickerAction& a, SyncActionValue_StickerAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_StickerAction* 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(SyncActionValue_StickerAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_StickerAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_StickerAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_StickerAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_StickerAction& from) {
    SyncActionValue_StickerAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_StickerAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.StickerAction";
  }
  protected:
  explicit SyncActionValue_StickerAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUrlFieldNumber = 1,
    kFileEncSha256FieldNumber = 2,
    kMediaKeyFieldNumber = 3,
    kMimetypeFieldNumber = 4,
    kDirectPathFieldNumber = 7,
    kHeightFieldNumber = 5,
    kWidthFieldNumber = 6,
    kFileLengthFieldNumber = 8,
    kIsFavoriteFieldNumber = 9,
    kDeviceIdHintFieldNumber = 10,
  };
  // optional 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 bytes fileEncSha256 = 2;
  bool has_fileencsha256() const;
  private:
  bool _internal_has_fileencsha256() const;
  public:
  void clear_fileencsha256();
  const std::string& fileencsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_fileencsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_fileencsha256();
  PROTOBUF_NODISCARD std::string* release_fileencsha256();
  void set_allocated_fileencsha256(std::string* fileencsha256);
  private:
  const std::string& _internal_fileencsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_fileencsha256(const std::string& value);
  std::string* _internal_mutable_fileencsha256();
  public:

  // optional bytes mediaKey = 3;
  bool has_mediakey() const;
  private:
  bool _internal_has_mediakey() const;
  public:
  void clear_mediakey();
  const std::string& mediakey() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediakey(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediakey();
  PROTOBUF_NODISCARD std::string* release_mediakey();
  void set_allocated_mediakey(std::string* mediakey);
  private:
  const std::string& _internal_mediakey() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediakey(const std::string& value);
  std::string* _internal_mutable_mediakey();
  public:

  // optional string mimetype = 4;
  bool has_mimetype() const;
  private:
  bool _internal_has_mimetype() const;
  public:
  void clear_mimetype();
  const std::string& mimetype() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mimetype(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mimetype();
  PROTOBUF_NODISCARD std::string* release_mimetype();
  void set_allocated_mimetype(std::string* mimetype);
  private:
  const std::string& _internal_mimetype() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mimetype(const std::string& value);
  std::string* _internal_mutable_mimetype();
  public:

  // optional string directPath = 7;
  bool has_directpath() const;
  private:
  bool _internal_has_directpath() const;
  public:
  void clear_directpath();
  const std::string& directpath() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_directpath(ArgT0&& arg0, ArgT... args);
  std::string* mutable_directpath();
  PROTOBUF_NODISCARD std::string* release_directpath();
  void set_allocated_directpath(std::string* directpath);
  private:
  const std::string& _internal_directpath() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_directpath(const std::string& value);
  std::string* _internal_mutable_directpath();
  public:

  // optional uint32 height = 5;
  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:

  // optional uint32 width = 6;
  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 uint64 fileLength = 8;
  bool has_filelength() const;
  private:
  bool _internal_has_filelength() const;
  public:
  void clear_filelength();
  uint64_t filelength() const;
  void set_filelength(uint64_t value);
  private:
  uint64_t _internal_filelength() const;
  void _internal_set_filelength(uint64_t value);
  public:

  // optional bool isFavorite = 9;
  bool has_isfavorite() const;
  private:
  bool _internal_has_isfavorite() const;
  public:
  void clear_isfavorite();
  bool isfavorite() const;
  void set_isfavorite(bool value);
  private:
  bool _internal_isfavorite() const;
  void _internal_set_isfavorite(bool value);
  public:

  // optional uint32 deviceIdHint = 10;
  bool has_deviceidhint() const;
  private:
  bool _internal_has_deviceidhint() const;
  public:
  void clear_deviceidhint();
  uint32_t deviceidhint() const;
  void set_deviceidhint(uint32_t value);
  private:
  uint32_t _internal_deviceidhint() const;
  void _internal_set_deviceidhint(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.StickerAction)
 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 fileencsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediakey_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mimetype_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directpath_;
    uint32_t height_;
    uint32_t width_;
    uint64_t filelength_;
    bool isfavorite_;
    uint32_t deviceidhint_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_SubscriptionAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SubscriptionAction) */ {
 public:
  inline SyncActionValue_SubscriptionAction() : SyncActionValue_SubscriptionAction(nullptr) {}
  ~SyncActionValue_SubscriptionAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_SubscriptionAction(const SyncActionValue_SubscriptionAction& from);
  SyncActionValue_SubscriptionAction(SyncActionValue_SubscriptionAction&& from) noexcept
    : SyncActionValue_SubscriptionAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_SubscriptionAction& operator=(const SyncActionValue_SubscriptionAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_SubscriptionAction& operator=(SyncActionValue_SubscriptionAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_SubscriptionAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_SubscriptionAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_SubscriptionAction*>(
               &_SyncActionValue_SubscriptionAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    198;

  friend void swap(SyncActionValue_SubscriptionAction& a, SyncActionValue_SubscriptionAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_SubscriptionAction* 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(SyncActionValue_SubscriptionAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_SubscriptionAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_SubscriptionAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_SubscriptionAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_SubscriptionAction& from) {
    SyncActionValue_SubscriptionAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_SubscriptionAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.SubscriptionAction";
  }
  protected:
  explicit SyncActionValue_SubscriptionAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kExpirationDateFieldNumber = 3,
    kIsDeactivatedFieldNumber = 1,
    kIsAutoRenewingFieldNumber = 2,
  };
  // optional int64 expirationDate = 3;
  bool has_expirationdate() const;
  private:
  bool _internal_has_expirationdate() const;
  public:
  void clear_expirationdate();
  int64_t expirationdate() const;
  void set_expirationdate(int64_t value);
  private:
  int64_t _internal_expirationdate() const;
  void _internal_set_expirationdate(int64_t value);
  public:

  // optional bool isDeactivated = 1;
  bool has_isdeactivated() const;
  private:
  bool _internal_has_isdeactivated() const;
  public:
  void clear_isdeactivated();
  bool isdeactivated() const;
  void set_isdeactivated(bool value);
  private:
  bool _internal_isdeactivated() const;
  void _internal_set_isdeactivated(bool value);
  public:

  // optional bool isAutoRenewing = 2;
  bool has_isautorenewing() const;
  private:
  bool _internal_has_isautorenewing() const;
  public:
  void clear_isautorenewing();
  bool isautorenewing() const;
  void set_isautorenewing(bool value);
  private:
  bool _internal_isautorenewing() const;
  void _internal_set_isautorenewing(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SubscriptionAction)
 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_;
    int64_t expirationdate_;
    bool isdeactivated_;
    bool isautorenewing_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_SyncActionMessageRange final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessageRange) */ {
 public:
  inline SyncActionValue_SyncActionMessageRange() : SyncActionValue_SyncActionMessageRange(nullptr) {}
  ~SyncActionValue_SyncActionMessageRange() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_SyncActionMessageRange(const SyncActionValue_SyncActionMessageRange& from);
  SyncActionValue_SyncActionMessageRange(SyncActionValue_SyncActionMessageRange&& from) noexcept
    : SyncActionValue_SyncActionMessageRange() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_SyncActionMessageRange& operator=(const SyncActionValue_SyncActionMessageRange& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_SyncActionMessageRange& operator=(SyncActionValue_SyncActionMessageRange&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_SyncActionMessageRange& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_SyncActionMessageRange* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_SyncActionMessageRange*>(
               &_SyncActionValue_SyncActionMessageRange_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    199;

  friend void swap(SyncActionValue_SyncActionMessageRange& a, SyncActionValue_SyncActionMessageRange& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_SyncActionMessageRange* 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(SyncActionValue_SyncActionMessageRange* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_SyncActionMessageRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_SyncActionMessageRange>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_SyncActionMessageRange& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_SyncActionMessageRange& from) {
    SyncActionValue_SyncActionMessageRange::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_SyncActionMessageRange* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.SyncActionMessageRange";
  }
  protected:
  explicit SyncActionValue_SyncActionMessageRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMessagesFieldNumber = 3,
    kLastMessageTimestampFieldNumber = 1,
    kLastSystemMessageTimestampFieldNumber = 2,
  };
  // repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
  int messages_size() const;
  private:
  int _internal_messages_size() const;
  public:
  void clear_messages();
  ::proto::SyncActionValue_SyncActionMessage* mutable_messages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >*
      mutable_messages();
  private:
  const ::proto::SyncActionValue_SyncActionMessage& _internal_messages(int index) const;
  ::proto::SyncActionValue_SyncActionMessage* _internal_add_messages();
  public:
  const ::proto::SyncActionValue_SyncActionMessage& messages(int index) const;
  ::proto::SyncActionValue_SyncActionMessage* add_messages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >&
      messages() const;

  // optional int64 lastMessageTimestamp = 1;
  bool has_lastmessagetimestamp() const;
  private:
  bool _internal_has_lastmessagetimestamp() const;
  public:
  void clear_lastmessagetimestamp();
  int64_t lastmessagetimestamp() const;
  void set_lastmessagetimestamp(int64_t value);
  private:
  int64_t _internal_lastmessagetimestamp() const;
  void _internal_set_lastmessagetimestamp(int64_t value);
  public:

  // optional int64 lastSystemMessageTimestamp = 2;
  bool has_lastsystemmessagetimestamp() const;
  private:
  bool _internal_has_lastsystemmessagetimestamp() const;
  public:
  void clear_lastsystemmessagetimestamp();
  int64_t lastsystemmessagetimestamp() const;
  void set_lastsystemmessagetimestamp(int64_t value);
  private:
  int64_t _internal_lastsystemmessagetimestamp() const;
  void _internal_set_lastsystemmessagetimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessageRange)
 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< ::proto::SyncActionValue_SyncActionMessage > messages_;
    int64_t lastmessagetimestamp_;
    int64_t lastsystemmessagetimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_SyncActionMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.SyncActionMessage) */ {
 public:
  inline SyncActionValue_SyncActionMessage() : SyncActionValue_SyncActionMessage(nullptr) {}
  ~SyncActionValue_SyncActionMessage() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_SyncActionMessage(const SyncActionValue_SyncActionMessage& from);
  SyncActionValue_SyncActionMessage(SyncActionValue_SyncActionMessage&& from) noexcept
    : SyncActionValue_SyncActionMessage() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_SyncActionMessage& operator=(const SyncActionValue_SyncActionMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_SyncActionMessage& operator=(SyncActionValue_SyncActionMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_SyncActionMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_SyncActionMessage* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_SyncActionMessage*>(
               &_SyncActionValue_SyncActionMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    200;

  friend void swap(SyncActionValue_SyncActionMessage& a, SyncActionValue_SyncActionMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_SyncActionMessage* 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(SyncActionValue_SyncActionMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_SyncActionMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_SyncActionMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_SyncActionMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_SyncActionMessage& from) {
    SyncActionValue_SyncActionMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_SyncActionMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.SyncActionMessage";
  }
  protected:
  explicit SyncActionValue_SyncActionMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kKeyFieldNumber = 1,
    kTimestampFieldNumber = 2,
  };
  // optional .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional int64 timestamp = 2;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.SyncActionMessage)
 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_;
    ::proto::MessageKey* key_;
    int64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_TimeFormatAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.TimeFormatAction) */ {
 public:
  inline SyncActionValue_TimeFormatAction() : SyncActionValue_TimeFormatAction(nullptr) {}
  ~SyncActionValue_TimeFormatAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_TimeFormatAction(const SyncActionValue_TimeFormatAction& from);
  SyncActionValue_TimeFormatAction(SyncActionValue_TimeFormatAction&& from) noexcept
    : SyncActionValue_TimeFormatAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_TimeFormatAction& operator=(const SyncActionValue_TimeFormatAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_TimeFormatAction& operator=(SyncActionValue_TimeFormatAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_TimeFormatAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_TimeFormatAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_TimeFormatAction*>(
               &_SyncActionValue_TimeFormatAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    201;

  friend void swap(SyncActionValue_TimeFormatAction& a, SyncActionValue_TimeFormatAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_TimeFormatAction* 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(SyncActionValue_TimeFormatAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_TimeFormatAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_TimeFormatAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_TimeFormatAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_TimeFormatAction& from) {
    SyncActionValue_TimeFormatAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_TimeFormatAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.TimeFormatAction";
  }
  protected:
  explicit SyncActionValue_TimeFormatAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIsTwentyFourHourFormatEnabledFieldNumber = 1,
  };
  // optional bool isTwentyFourHourFormatEnabled = 1;
  bool has_istwentyfourhourformatenabled() const;
  private:
  bool _internal_has_istwentyfourhourformatenabled() const;
  public:
  void clear_istwentyfourhourformatenabled();
  bool istwentyfourhourformatenabled() const;
  void set_istwentyfourhourformatenabled(bool value);
  private:
  bool _internal_istwentyfourhourformatenabled() const;
  void _internal_set_istwentyfourhourformatenabled(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.TimeFormatAction)
 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 istwentyfourhourformatenabled_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_UnarchiveChatsSetting final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UnarchiveChatsSetting) */ {
 public:
  inline SyncActionValue_UnarchiveChatsSetting() : SyncActionValue_UnarchiveChatsSetting(nullptr) {}
  ~SyncActionValue_UnarchiveChatsSetting() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_UnarchiveChatsSetting(const SyncActionValue_UnarchiveChatsSetting& from);
  SyncActionValue_UnarchiveChatsSetting(SyncActionValue_UnarchiveChatsSetting&& from) noexcept
    : SyncActionValue_UnarchiveChatsSetting() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_UnarchiveChatsSetting& operator=(const SyncActionValue_UnarchiveChatsSetting& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_UnarchiveChatsSetting& operator=(SyncActionValue_UnarchiveChatsSetting&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_UnarchiveChatsSetting& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_UnarchiveChatsSetting* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_UnarchiveChatsSetting*>(
               &_SyncActionValue_UnarchiveChatsSetting_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    202;

  friend void swap(SyncActionValue_UnarchiveChatsSetting& a, SyncActionValue_UnarchiveChatsSetting& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_UnarchiveChatsSetting* 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(SyncActionValue_UnarchiveChatsSetting* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_UnarchiveChatsSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_UnarchiveChatsSetting>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_UnarchiveChatsSetting& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_UnarchiveChatsSetting& from) {
    SyncActionValue_UnarchiveChatsSetting::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_UnarchiveChatsSetting* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.UnarchiveChatsSetting";
  }
  protected:
  explicit SyncActionValue_UnarchiveChatsSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kUnarchiveChatsFieldNumber = 1,
  };
  // optional bool unarchiveChats = 1;
  bool has_unarchivechats() const;
  private:
  bool _internal_has_unarchivechats() const;
  public:
  void clear_unarchivechats();
  bool unarchivechats() const;
  void set_unarchivechats(bool value);
  private:
  bool _internal_unarchivechats() const;
  void _internal_set_unarchivechats(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UnarchiveChatsSetting)
 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 unarchivechats_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue_UserStatusMuteAction final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue.UserStatusMuteAction) */ {
 public:
  inline SyncActionValue_UserStatusMuteAction() : SyncActionValue_UserStatusMuteAction(nullptr) {}
  ~SyncActionValue_UserStatusMuteAction() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue_UserStatusMuteAction(const SyncActionValue_UserStatusMuteAction& from);
  SyncActionValue_UserStatusMuteAction(SyncActionValue_UserStatusMuteAction&& from) noexcept
    : SyncActionValue_UserStatusMuteAction() {
    *this = ::std::move(from);
  }

  inline SyncActionValue_UserStatusMuteAction& operator=(const SyncActionValue_UserStatusMuteAction& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue_UserStatusMuteAction& operator=(SyncActionValue_UserStatusMuteAction&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue_UserStatusMuteAction& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue_UserStatusMuteAction* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue_UserStatusMuteAction*>(
               &_SyncActionValue_UserStatusMuteAction_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    203;

  friend void swap(SyncActionValue_UserStatusMuteAction& a, SyncActionValue_UserStatusMuteAction& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue_UserStatusMuteAction* 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(SyncActionValue_UserStatusMuteAction* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue_UserStatusMuteAction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue_UserStatusMuteAction>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue_UserStatusMuteAction& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue_UserStatusMuteAction& from) {
    SyncActionValue_UserStatusMuteAction::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue_UserStatusMuteAction* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue.UserStatusMuteAction";
  }
  protected:
  explicit SyncActionValue_UserStatusMuteAction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMutedFieldNumber = 1,
  };
  // optional bool muted = 1;
  bool has_muted() const;
  private:
  bool _internal_has_muted() const;
  public:
  void clear_muted();
  bool muted() const;
  void set_muted(bool value);
  private:
  bool _internal_muted() const;
  void _internal_set_muted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue.UserStatusMuteAction)
 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 muted_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncActionValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncActionValue) */ {
 public:
  inline SyncActionValue() : SyncActionValue(nullptr) {}
  ~SyncActionValue() override;
  explicit PROTOBUF_CONSTEXPR SyncActionValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncActionValue(const SyncActionValue& from);
  SyncActionValue(SyncActionValue&& from) noexcept
    : SyncActionValue() {
    *this = ::std::move(from);
  }

  inline SyncActionValue& operator=(const SyncActionValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncActionValue& operator=(SyncActionValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncActionValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncActionValue* internal_default_instance() {
    return reinterpret_cast<const SyncActionValue*>(
               &_SyncActionValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    204;

  friend void swap(SyncActionValue& a, SyncActionValue& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncActionValue* 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(SyncActionValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncActionValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncActionValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncActionValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncActionValue& from) {
    SyncActionValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncActionValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncActionValue";
  }
  protected:
  explicit SyncActionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef SyncActionValue_AgentAction AgentAction;
  typedef SyncActionValue_AndroidUnsupportedActions AndroidUnsupportedActions;
  typedef SyncActionValue_ArchiveChatAction ArchiveChatAction;
  typedef SyncActionValue_ClearChatAction ClearChatAction;
  typedef SyncActionValue_ContactAction ContactAction;
  typedef SyncActionValue_DeleteChatAction DeleteChatAction;
  typedef SyncActionValue_DeleteMessageForMeAction DeleteMessageForMeAction;
  typedef SyncActionValue_KeyExpiration KeyExpiration;
  typedef SyncActionValue_LabelAssociationAction LabelAssociationAction;
  typedef SyncActionValue_LabelEditAction LabelEditAction;
  typedef SyncActionValue_LocaleSetting LocaleSetting;
  typedef SyncActionValue_MarkChatAsReadAction MarkChatAsReadAction;
  typedef SyncActionValue_MuteAction MuteAction;
  typedef SyncActionValue_NuxAction NuxAction;
  typedef SyncActionValue_PinAction PinAction;
  typedef SyncActionValue_PrimaryFeature PrimaryFeature;
  typedef SyncActionValue_PrimaryVersionAction PrimaryVersionAction;
  typedef SyncActionValue_PushNameSetting PushNameSetting;
  typedef SyncActionValue_QuickReplyAction QuickReplyAction;
  typedef SyncActionValue_RecentEmojiWeightsAction RecentEmojiWeightsAction;
  typedef SyncActionValue_SecurityNotificationSetting SecurityNotificationSetting;
  typedef SyncActionValue_StarAction StarAction;
  typedef SyncActionValue_StickerAction StickerAction;
  typedef SyncActionValue_SubscriptionAction SubscriptionAction;
  typedef SyncActionValue_SyncActionMessageRange SyncActionMessageRange;
  typedef SyncActionValue_SyncActionMessage SyncActionMessage;
  typedef SyncActionValue_TimeFormatAction TimeFormatAction;
  typedef SyncActionValue_UnarchiveChatsSetting UnarchiveChatsSetting;
  typedef SyncActionValue_UserStatusMuteAction UserStatusMuteAction;

  // accessors -------------------------------------------------------

  enum : int {
    kStarActionFieldNumber = 2,
    kContactActionFieldNumber = 3,
    kMuteActionFieldNumber = 4,
    kPinActionFieldNumber = 5,
    kSecurityNotificationSettingFieldNumber = 6,
    kPushNameSettingFieldNumber = 7,
    kQuickReplyActionFieldNumber = 8,
    kRecentEmojiWeightsActionFieldNumber = 11,
    kLabelEditActionFieldNumber = 14,
    kLabelAssociationActionFieldNumber = 15,
    kLocaleSettingFieldNumber = 16,
    kArchiveChatActionFieldNumber = 17,
    kDeleteMessageForMeActionFieldNumber = 18,
    kKeyExpirationFieldNumber = 19,
    kMarkChatAsReadActionFieldNumber = 20,
    kClearChatActionFieldNumber = 21,
    kDeleteChatActionFieldNumber = 22,
    kUnarchiveChatsSettingFieldNumber = 23,
    kPrimaryFeatureFieldNumber = 24,
    kAndroidUnsupportedActionsFieldNumber = 26,
    kAgentActionFieldNumber = 27,
    kSubscriptionActionFieldNumber = 28,
    kUserStatusMuteActionFieldNumber = 29,
    kTimeFormatActionFieldNumber = 30,
    kNuxActionFieldNumber = 31,
    kPrimaryVersionActionFieldNumber = 32,
    kStickerActionFieldNumber = 33,
    kTimestampFieldNumber = 1,
  };
  // optional .proto.SyncActionValue.StarAction starAction = 2;
  bool has_staraction() const;
  private:
  bool _internal_has_staraction() const;
  public:
  void clear_staraction();
  const ::proto::SyncActionValue_StarAction& staraction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_StarAction* release_staraction();
  ::proto::SyncActionValue_StarAction* mutable_staraction();
  void set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction);
  private:
  const ::proto::SyncActionValue_StarAction& _internal_staraction() const;
  ::proto::SyncActionValue_StarAction* _internal_mutable_staraction();
  public:
  void unsafe_arena_set_allocated_staraction(
      ::proto::SyncActionValue_StarAction* staraction);
  ::proto::SyncActionValue_StarAction* unsafe_arena_release_staraction();

  // optional .proto.SyncActionValue.ContactAction contactAction = 3;
  bool has_contactaction() const;
  private:
  bool _internal_has_contactaction() const;
  public:
  void clear_contactaction();
  const ::proto::SyncActionValue_ContactAction& contactaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_ContactAction* release_contactaction();
  ::proto::SyncActionValue_ContactAction* mutable_contactaction();
  void set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction);
  private:
  const ::proto::SyncActionValue_ContactAction& _internal_contactaction() const;
  ::proto::SyncActionValue_ContactAction* _internal_mutable_contactaction();
  public:
  void unsafe_arena_set_allocated_contactaction(
      ::proto::SyncActionValue_ContactAction* contactaction);
  ::proto::SyncActionValue_ContactAction* unsafe_arena_release_contactaction();

  // optional .proto.SyncActionValue.MuteAction muteAction = 4;
  bool has_muteaction() const;
  private:
  bool _internal_has_muteaction() const;
  public:
  void clear_muteaction();
  const ::proto::SyncActionValue_MuteAction& muteaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_MuteAction* release_muteaction();
  ::proto::SyncActionValue_MuteAction* mutable_muteaction();
  void set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction);
  private:
  const ::proto::SyncActionValue_MuteAction& _internal_muteaction() const;
  ::proto::SyncActionValue_MuteAction* _internal_mutable_muteaction();
  public:
  void unsafe_arena_set_allocated_muteaction(
      ::proto::SyncActionValue_MuteAction* muteaction);
  ::proto::SyncActionValue_MuteAction* unsafe_arena_release_muteaction();

  // optional .proto.SyncActionValue.PinAction pinAction = 5;
  bool has_pinaction() const;
  private:
  bool _internal_has_pinaction() const;
  public:
  void clear_pinaction();
  const ::proto::SyncActionValue_PinAction& pinaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_PinAction* release_pinaction();
  ::proto::SyncActionValue_PinAction* mutable_pinaction();
  void set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction);
  private:
  const ::proto::SyncActionValue_PinAction& _internal_pinaction() const;
  ::proto::SyncActionValue_PinAction* _internal_mutable_pinaction();
  public:
  void unsafe_arena_set_allocated_pinaction(
      ::proto::SyncActionValue_PinAction* pinaction);
  ::proto::SyncActionValue_PinAction* unsafe_arena_release_pinaction();

  // optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
  bool has_securitynotificationsetting() const;
  private:
  bool _internal_has_securitynotificationsetting() const;
  public:
  void clear_securitynotificationsetting();
  const ::proto::SyncActionValue_SecurityNotificationSetting& securitynotificationsetting() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SecurityNotificationSetting* release_securitynotificationsetting();
  ::proto::SyncActionValue_SecurityNotificationSetting* mutable_securitynotificationsetting();
  void set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting);
  private:
  const ::proto::SyncActionValue_SecurityNotificationSetting& _internal_securitynotificationsetting() const;
  ::proto::SyncActionValue_SecurityNotificationSetting* _internal_mutable_securitynotificationsetting();
  public:
  void unsafe_arena_set_allocated_securitynotificationsetting(
      ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting);
  ::proto::SyncActionValue_SecurityNotificationSetting* unsafe_arena_release_securitynotificationsetting();

  // optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
  bool has_pushnamesetting() const;
  private:
  bool _internal_has_pushnamesetting() const;
  public:
  void clear_pushnamesetting();
  const ::proto::SyncActionValue_PushNameSetting& pushnamesetting() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_PushNameSetting* release_pushnamesetting();
  ::proto::SyncActionValue_PushNameSetting* mutable_pushnamesetting();
  void set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting);
  private:
  const ::proto::SyncActionValue_PushNameSetting& _internal_pushnamesetting() const;
  ::proto::SyncActionValue_PushNameSetting* _internal_mutable_pushnamesetting();
  public:
  void unsafe_arena_set_allocated_pushnamesetting(
      ::proto::SyncActionValue_PushNameSetting* pushnamesetting);
  ::proto::SyncActionValue_PushNameSetting* unsafe_arena_release_pushnamesetting();

  // optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
  bool has_quickreplyaction() const;
  private:
  bool _internal_has_quickreplyaction() const;
  public:
  void clear_quickreplyaction();
  const ::proto::SyncActionValue_QuickReplyAction& quickreplyaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_QuickReplyAction* release_quickreplyaction();
  ::proto::SyncActionValue_QuickReplyAction* mutable_quickreplyaction();
  void set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction);
  private:
  const ::proto::SyncActionValue_QuickReplyAction& _internal_quickreplyaction() const;
  ::proto::SyncActionValue_QuickReplyAction* _internal_mutable_quickreplyaction();
  public:
  void unsafe_arena_set_allocated_quickreplyaction(
      ::proto::SyncActionValue_QuickReplyAction* quickreplyaction);
  ::proto::SyncActionValue_QuickReplyAction* unsafe_arena_release_quickreplyaction();

  // optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
  bool has_recentemojiweightsaction() const;
  private:
  bool _internal_has_recentemojiweightsaction() const;
  public:
  void clear_recentemojiweightsaction();
  const ::proto::SyncActionValue_RecentEmojiWeightsAction& recentemojiweightsaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_RecentEmojiWeightsAction* release_recentemojiweightsaction();
  ::proto::SyncActionValue_RecentEmojiWeightsAction* mutable_recentemojiweightsaction();
  void set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction);
  private:
  const ::proto::SyncActionValue_RecentEmojiWeightsAction& _internal_recentemojiweightsaction() const;
  ::proto::SyncActionValue_RecentEmojiWeightsAction* _internal_mutable_recentemojiweightsaction();
  public:
  void unsafe_arena_set_allocated_recentemojiweightsaction(
      ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction);
  ::proto::SyncActionValue_RecentEmojiWeightsAction* unsafe_arena_release_recentemojiweightsaction();

  // optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
  bool has_labeleditaction() const;
  private:
  bool _internal_has_labeleditaction() const;
  public:
  void clear_labeleditaction();
  const ::proto::SyncActionValue_LabelEditAction& labeleditaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelEditAction* release_labeleditaction();
  ::proto::SyncActionValue_LabelEditAction* mutable_labeleditaction();
  void set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction);
  private:
  const ::proto::SyncActionValue_LabelEditAction& _internal_labeleditaction() const;
  ::proto::SyncActionValue_LabelEditAction* _internal_mutable_labeleditaction();
  public:
  void unsafe_arena_set_allocated_labeleditaction(
      ::proto::SyncActionValue_LabelEditAction* labeleditaction);
  ::proto::SyncActionValue_LabelEditAction* unsafe_arena_release_labeleditaction();

  // optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
  bool has_labelassociationaction() const;
  private:
  bool _internal_has_labelassociationaction() const;
  public:
  void clear_labelassociationaction();
  const ::proto::SyncActionValue_LabelAssociationAction& labelassociationaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_LabelAssociationAction* release_labelassociationaction();
  ::proto::SyncActionValue_LabelAssociationAction* mutable_labelassociationaction();
  void set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction);
  private:
  const ::proto::SyncActionValue_LabelAssociationAction& _internal_labelassociationaction() const;
  ::proto::SyncActionValue_LabelAssociationAction* _internal_mutable_labelassociationaction();
  public:
  void unsafe_arena_set_allocated_labelassociationaction(
      ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction);
  ::proto::SyncActionValue_LabelAssociationAction* unsafe_arena_release_labelassociationaction();

  // optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
  bool has_localesetting() const;
  private:
  bool _internal_has_localesetting() const;
  public:
  void clear_localesetting();
  const ::proto::SyncActionValue_LocaleSetting& localesetting() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_LocaleSetting* release_localesetting();
  ::proto::SyncActionValue_LocaleSetting* mutable_localesetting();
  void set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting);
  private:
  const ::proto::SyncActionValue_LocaleSetting& _internal_localesetting() const;
  ::proto::SyncActionValue_LocaleSetting* _internal_mutable_localesetting();
  public:
  void unsafe_arena_set_allocated_localesetting(
      ::proto::SyncActionValue_LocaleSetting* localesetting);
  ::proto::SyncActionValue_LocaleSetting* unsafe_arena_release_localesetting();

  // optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
  bool has_archivechataction() const;
  private:
  bool _internal_has_archivechataction() const;
  public:
  void clear_archivechataction();
  const ::proto::SyncActionValue_ArchiveChatAction& archivechataction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_ArchiveChatAction* release_archivechataction();
  ::proto::SyncActionValue_ArchiveChatAction* mutable_archivechataction();
  void set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction);
  private:
  const ::proto::SyncActionValue_ArchiveChatAction& _internal_archivechataction() const;
  ::proto::SyncActionValue_ArchiveChatAction* _internal_mutable_archivechataction();
  public:
  void unsafe_arena_set_allocated_archivechataction(
      ::proto::SyncActionValue_ArchiveChatAction* archivechataction);
  ::proto::SyncActionValue_ArchiveChatAction* unsafe_arena_release_archivechataction();

  // optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
  bool has_deletemessageformeaction() const;
  private:
  bool _internal_has_deletemessageformeaction() const;
  public:
  void clear_deletemessageformeaction();
  const ::proto::SyncActionValue_DeleteMessageForMeAction& deletemessageformeaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteMessageForMeAction* release_deletemessageformeaction();
  ::proto::SyncActionValue_DeleteMessageForMeAction* mutable_deletemessageformeaction();
  void set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction);
  private:
  const ::proto::SyncActionValue_DeleteMessageForMeAction& _internal_deletemessageformeaction() const;
  ::proto::SyncActionValue_DeleteMessageForMeAction* _internal_mutable_deletemessageformeaction();
  public:
  void unsafe_arena_set_allocated_deletemessageformeaction(
      ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction);
  ::proto::SyncActionValue_DeleteMessageForMeAction* unsafe_arena_release_deletemessageformeaction();

  // optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
  bool has_keyexpiration() const;
  private:
  bool _internal_has_keyexpiration() const;
  public:
  void clear_keyexpiration();
  const ::proto::SyncActionValue_KeyExpiration& keyexpiration() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_KeyExpiration* release_keyexpiration();
  ::proto::SyncActionValue_KeyExpiration* mutable_keyexpiration();
  void set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration);
  private:
  const ::proto::SyncActionValue_KeyExpiration& _internal_keyexpiration() const;
  ::proto::SyncActionValue_KeyExpiration* _internal_mutable_keyexpiration();
  public:
  void unsafe_arena_set_allocated_keyexpiration(
      ::proto::SyncActionValue_KeyExpiration* keyexpiration);
  ::proto::SyncActionValue_KeyExpiration* unsafe_arena_release_keyexpiration();

  // optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
  bool has_markchatasreadaction() const;
  private:
  bool _internal_has_markchatasreadaction() const;
  public:
  void clear_markchatasreadaction();
  const ::proto::SyncActionValue_MarkChatAsReadAction& markchatasreadaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_MarkChatAsReadAction* release_markchatasreadaction();
  ::proto::SyncActionValue_MarkChatAsReadAction* mutable_markchatasreadaction();
  void set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction);
  private:
  const ::proto::SyncActionValue_MarkChatAsReadAction& _internal_markchatasreadaction() const;
  ::proto::SyncActionValue_MarkChatAsReadAction* _internal_mutable_markchatasreadaction();
  public:
  void unsafe_arena_set_allocated_markchatasreadaction(
      ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction);
  ::proto::SyncActionValue_MarkChatAsReadAction* unsafe_arena_release_markchatasreadaction();

  // optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
  bool has_clearchataction() const;
  private:
  bool _internal_has_clearchataction() const;
  public:
  void clear_clearchataction();
  const ::proto::SyncActionValue_ClearChatAction& clearchataction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_ClearChatAction* release_clearchataction();
  ::proto::SyncActionValue_ClearChatAction* mutable_clearchataction();
  void set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction);
  private:
  const ::proto::SyncActionValue_ClearChatAction& _internal_clearchataction() const;
  ::proto::SyncActionValue_ClearChatAction* _internal_mutable_clearchataction();
  public:
  void unsafe_arena_set_allocated_clearchataction(
      ::proto::SyncActionValue_ClearChatAction* clearchataction);
  ::proto::SyncActionValue_ClearChatAction* unsafe_arena_release_clearchataction();

  // optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
  bool has_deletechataction() const;
  private:
  bool _internal_has_deletechataction() const;
  public:
  void clear_deletechataction();
  const ::proto::SyncActionValue_DeleteChatAction& deletechataction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_DeleteChatAction* release_deletechataction();
  ::proto::SyncActionValue_DeleteChatAction* mutable_deletechataction();
  void set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction);
  private:
  const ::proto::SyncActionValue_DeleteChatAction& _internal_deletechataction() const;
  ::proto::SyncActionValue_DeleteChatAction* _internal_mutable_deletechataction();
  public:
  void unsafe_arena_set_allocated_deletechataction(
      ::proto::SyncActionValue_DeleteChatAction* deletechataction);
  ::proto::SyncActionValue_DeleteChatAction* unsafe_arena_release_deletechataction();

  // optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
  bool has_unarchivechatssetting() const;
  private:
  bool _internal_has_unarchivechatssetting() const;
  public:
  void clear_unarchivechatssetting();
  const ::proto::SyncActionValue_UnarchiveChatsSetting& unarchivechatssetting() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_UnarchiveChatsSetting* release_unarchivechatssetting();
  ::proto::SyncActionValue_UnarchiveChatsSetting* mutable_unarchivechatssetting();
  void set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting);
  private:
  const ::proto::SyncActionValue_UnarchiveChatsSetting& _internal_unarchivechatssetting() const;
  ::proto::SyncActionValue_UnarchiveChatsSetting* _internal_mutable_unarchivechatssetting();
  public:
  void unsafe_arena_set_allocated_unarchivechatssetting(
      ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting);
  ::proto::SyncActionValue_UnarchiveChatsSetting* unsafe_arena_release_unarchivechatssetting();

  // optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
  bool has_primaryfeature() const;
  private:
  bool _internal_has_primaryfeature() const;
  public:
  void clear_primaryfeature();
  const ::proto::SyncActionValue_PrimaryFeature& primaryfeature() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryFeature* release_primaryfeature();
  ::proto::SyncActionValue_PrimaryFeature* mutable_primaryfeature();
  void set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature);
  private:
  const ::proto::SyncActionValue_PrimaryFeature& _internal_primaryfeature() const;
  ::proto::SyncActionValue_PrimaryFeature* _internal_mutable_primaryfeature();
  public:
  void unsafe_arena_set_allocated_primaryfeature(
      ::proto::SyncActionValue_PrimaryFeature* primaryfeature);
  ::proto::SyncActionValue_PrimaryFeature* unsafe_arena_release_primaryfeature();

  // optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
  bool has_androidunsupportedactions() const;
  private:
  bool _internal_has_androidunsupportedactions() const;
  public:
  void clear_androidunsupportedactions();
  const ::proto::SyncActionValue_AndroidUnsupportedActions& androidunsupportedactions() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_AndroidUnsupportedActions* release_androidunsupportedactions();
  ::proto::SyncActionValue_AndroidUnsupportedActions* mutable_androidunsupportedactions();
  void set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions);
  private:
  const ::proto::SyncActionValue_AndroidUnsupportedActions& _internal_androidunsupportedactions() const;
  ::proto::SyncActionValue_AndroidUnsupportedActions* _internal_mutable_androidunsupportedactions();
  public:
  void unsafe_arena_set_allocated_androidunsupportedactions(
      ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions);
  ::proto::SyncActionValue_AndroidUnsupportedActions* unsafe_arena_release_androidunsupportedactions();

  // optional .proto.SyncActionValue.AgentAction agentAction = 27;
  bool has_agentaction() const;
  private:
  bool _internal_has_agentaction() const;
  public:
  void clear_agentaction();
  const ::proto::SyncActionValue_AgentAction& agentaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_AgentAction* release_agentaction();
  ::proto::SyncActionValue_AgentAction* mutable_agentaction();
  void set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction);
  private:
  const ::proto::SyncActionValue_AgentAction& _internal_agentaction() const;
  ::proto::SyncActionValue_AgentAction* _internal_mutable_agentaction();
  public:
  void unsafe_arena_set_allocated_agentaction(
      ::proto::SyncActionValue_AgentAction* agentaction);
  ::proto::SyncActionValue_AgentAction* unsafe_arena_release_agentaction();

  // optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
  bool has_subscriptionaction() const;
  private:
  bool _internal_has_subscriptionaction() const;
  public:
  void clear_subscriptionaction();
  const ::proto::SyncActionValue_SubscriptionAction& subscriptionaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_SubscriptionAction* release_subscriptionaction();
  ::proto::SyncActionValue_SubscriptionAction* mutable_subscriptionaction();
  void set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction);
  private:
  const ::proto::SyncActionValue_SubscriptionAction& _internal_subscriptionaction() const;
  ::proto::SyncActionValue_SubscriptionAction* _internal_mutable_subscriptionaction();
  public:
  void unsafe_arena_set_allocated_subscriptionaction(
      ::proto::SyncActionValue_SubscriptionAction* subscriptionaction);
  ::proto::SyncActionValue_SubscriptionAction* unsafe_arena_release_subscriptionaction();

  // optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
  bool has_userstatusmuteaction() const;
  private:
  bool _internal_has_userstatusmuteaction() const;
  public:
  void clear_userstatusmuteaction();
  const ::proto::SyncActionValue_UserStatusMuteAction& userstatusmuteaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_UserStatusMuteAction* release_userstatusmuteaction();
  ::proto::SyncActionValue_UserStatusMuteAction* mutable_userstatusmuteaction();
  void set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction);
  private:
  const ::proto::SyncActionValue_UserStatusMuteAction& _internal_userstatusmuteaction() const;
  ::proto::SyncActionValue_UserStatusMuteAction* _internal_mutable_userstatusmuteaction();
  public:
  void unsafe_arena_set_allocated_userstatusmuteaction(
      ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction);
  ::proto::SyncActionValue_UserStatusMuteAction* unsafe_arena_release_userstatusmuteaction();

  // optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
  bool has_timeformataction() const;
  private:
  bool _internal_has_timeformataction() const;
  public:
  void clear_timeformataction();
  const ::proto::SyncActionValue_TimeFormatAction& timeformataction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_TimeFormatAction* release_timeformataction();
  ::proto::SyncActionValue_TimeFormatAction* mutable_timeformataction();
  void set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction);
  private:
  const ::proto::SyncActionValue_TimeFormatAction& _internal_timeformataction() const;
  ::proto::SyncActionValue_TimeFormatAction* _internal_mutable_timeformataction();
  public:
  void unsafe_arena_set_allocated_timeformataction(
      ::proto::SyncActionValue_TimeFormatAction* timeformataction);
  ::proto::SyncActionValue_TimeFormatAction* unsafe_arena_release_timeformataction();

  // optional .proto.SyncActionValue.NuxAction nuxAction = 31;
  bool has_nuxaction() const;
  private:
  bool _internal_has_nuxaction() const;
  public:
  void clear_nuxaction();
  const ::proto::SyncActionValue_NuxAction& nuxaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_NuxAction* release_nuxaction();
  ::proto::SyncActionValue_NuxAction* mutable_nuxaction();
  void set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction);
  private:
  const ::proto::SyncActionValue_NuxAction& _internal_nuxaction() const;
  ::proto::SyncActionValue_NuxAction* _internal_mutable_nuxaction();
  public:
  void unsafe_arena_set_allocated_nuxaction(
      ::proto::SyncActionValue_NuxAction* nuxaction);
  ::proto::SyncActionValue_NuxAction* unsafe_arena_release_nuxaction();

  // optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
  bool has_primaryversionaction() const;
  private:
  bool _internal_has_primaryversionaction() const;
  public:
  void clear_primaryversionaction();
  const ::proto::SyncActionValue_PrimaryVersionAction& primaryversionaction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_PrimaryVersionAction* release_primaryversionaction();
  ::proto::SyncActionValue_PrimaryVersionAction* mutable_primaryversionaction();
  void set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction);
  private:
  const ::proto::SyncActionValue_PrimaryVersionAction& _internal_primaryversionaction() const;
  ::proto::SyncActionValue_PrimaryVersionAction* _internal_mutable_primaryversionaction();
  public:
  void unsafe_arena_set_allocated_primaryversionaction(
      ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction);
  ::proto::SyncActionValue_PrimaryVersionAction* unsafe_arena_release_primaryversionaction();

  // optional .proto.SyncActionValue.StickerAction stickerAction = 33;
  bool has_stickeraction() const;
  private:
  bool _internal_has_stickeraction() const;
  public:
  void clear_stickeraction();
  const ::proto::SyncActionValue_StickerAction& stickeraction() const;
  PROTOBUF_NODISCARD ::proto::SyncActionValue_StickerAction* release_stickeraction();
  ::proto::SyncActionValue_StickerAction* mutable_stickeraction();
  void set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction);
  private:
  const ::proto::SyncActionValue_StickerAction& _internal_stickeraction() const;
  ::proto::SyncActionValue_StickerAction* _internal_mutable_stickeraction();
  public:
  void unsafe_arena_set_allocated_stickeraction(
      ::proto::SyncActionValue_StickerAction* stickeraction);
  ::proto::SyncActionValue_StickerAction* unsafe_arena_release_stickeraction();

  // optional int64 timestamp = 1;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  int64_t timestamp() const;
  void set_timestamp(int64_t value);
  private:
  int64_t _internal_timestamp() const;
  void _internal_set_timestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncActionValue)
 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_;
    ::proto::SyncActionValue_StarAction* staraction_;
    ::proto::SyncActionValue_ContactAction* contactaction_;
    ::proto::SyncActionValue_MuteAction* muteaction_;
    ::proto::SyncActionValue_PinAction* pinaction_;
    ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting_;
    ::proto::SyncActionValue_PushNameSetting* pushnamesetting_;
    ::proto::SyncActionValue_QuickReplyAction* quickreplyaction_;
    ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction_;
    ::proto::SyncActionValue_LabelEditAction* labeleditaction_;
    ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction_;
    ::proto::SyncActionValue_LocaleSetting* localesetting_;
    ::proto::SyncActionValue_ArchiveChatAction* archivechataction_;
    ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction_;
    ::proto::SyncActionValue_KeyExpiration* keyexpiration_;
    ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction_;
    ::proto::SyncActionValue_ClearChatAction* clearchataction_;
    ::proto::SyncActionValue_DeleteChatAction* deletechataction_;
    ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting_;
    ::proto::SyncActionValue_PrimaryFeature* primaryfeature_;
    ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions_;
    ::proto::SyncActionValue_AgentAction* agentaction_;
    ::proto::SyncActionValue_SubscriptionAction* subscriptionaction_;
    ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction_;
    ::proto::SyncActionValue_TimeFormatAction* timeformataction_;
    ::proto::SyncActionValue_NuxAction* nuxaction_;
    ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction_;
    ::proto::SyncActionValue_StickerAction* stickeraction_;
    int64_t timestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdIndex final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdIndex) */ {
 public:
  inline SyncdIndex() : SyncdIndex(nullptr) {}
  ~SyncdIndex() override;
  explicit PROTOBUF_CONSTEXPR SyncdIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdIndex(const SyncdIndex& from);
  SyncdIndex(SyncdIndex&& from) noexcept
    : SyncdIndex() {
    *this = ::std::move(from);
  }

  inline SyncdIndex& operator=(const SyncdIndex& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdIndex& operator=(SyncdIndex&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdIndex& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdIndex* internal_default_instance() {
    return reinterpret_cast<const SyncdIndex*>(
               &_SyncdIndex_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    205;

  friend void swap(SyncdIndex& a, SyncdIndex& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdIndex* 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(SyncdIndex* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdIndex>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdIndex& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdIndex& from) {
    SyncdIndex::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdIndex* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdIndex";
  }
  protected:
  explicit SyncdIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBlobFieldNumber = 1,
  };
  // optional bytes blob = 1;
  bool has_blob() const;
  private:
  bool _internal_has_blob() const;
  public:
  void clear_blob();
  const std::string& blob() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_blob(ArgT0&& arg0, ArgT... args);
  std::string* mutable_blob();
  PROTOBUF_NODISCARD std::string* release_blob();
  void set_allocated_blob(std::string* blob);
  private:
  const std::string& _internal_blob() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value);
  std::string* _internal_mutable_blob();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncdIndex)
 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 blob_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdMutation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutation) */ {
 public:
  inline SyncdMutation() : SyncdMutation(nullptr) {}
  ~SyncdMutation() override;
  explicit PROTOBUF_CONSTEXPR SyncdMutation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdMutation(const SyncdMutation& from);
  SyncdMutation(SyncdMutation&& from) noexcept
    : SyncdMutation() {
    *this = ::std::move(from);
  }

  inline SyncdMutation& operator=(const SyncdMutation& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdMutation& operator=(SyncdMutation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdMutation& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdMutation* internal_default_instance() {
    return reinterpret_cast<const SyncdMutation*>(
               &_SyncdMutation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    206;

  friend void swap(SyncdMutation& a, SyncdMutation& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdMutation* 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(SyncdMutation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdMutation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdMutation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdMutation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdMutation& from) {
    SyncdMutation::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdMutation* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdMutation";
  }
  protected:
  explicit SyncdMutation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef SyncdMutation_SyncdOperation SyncdOperation;
  static constexpr SyncdOperation SET =
    SyncdMutation_SyncdOperation_SET;
  static constexpr SyncdOperation REMOVE =
    SyncdMutation_SyncdOperation_REMOVE;
  static inline bool SyncdOperation_IsValid(int value) {
    return SyncdMutation_SyncdOperation_IsValid(value);
  }
  static constexpr SyncdOperation SyncdOperation_MIN =
    SyncdMutation_SyncdOperation_SyncdOperation_MIN;
  static constexpr SyncdOperation SyncdOperation_MAX =
    SyncdMutation_SyncdOperation_SyncdOperation_MAX;
  static constexpr int SyncdOperation_ARRAYSIZE =
    SyncdMutation_SyncdOperation_SyncdOperation_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SyncdOperation_descriptor() {
    return SyncdMutation_SyncdOperation_descriptor();
  }
  template<typename T>
  static inline const std::string& SyncdOperation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SyncdOperation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SyncdOperation_Name.");
    return SyncdMutation_SyncdOperation_Name(enum_t_value);
  }
  static inline bool SyncdOperation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      SyncdOperation* value) {
    return SyncdMutation_SyncdOperation_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kRecordFieldNumber = 2,
    kOperationFieldNumber = 1,
  };
  // optional .proto.SyncdRecord record = 2;
  bool has_record() const;
  private:
  bool _internal_has_record() const;
  public:
  void clear_record();
  const ::proto::SyncdRecord& record() const;
  PROTOBUF_NODISCARD ::proto::SyncdRecord* release_record();
  ::proto::SyncdRecord* mutable_record();
  void set_allocated_record(::proto::SyncdRecord* record);
  private:
  const ::proto::SyncdRecord& _internal_record() const;
  ::proto::SyncdRecord* _internal_mutable_record();
  public:
  void unsafe_arena_set_allocated_record(
      ::proto::SyncdRecord* record);
  ::proto::SyncdRecord* unsafe_arena_release_record();

  // optional .proto.SyncdMutation.SyncdOperation operation = 1;
  bool has_operation() const;
  private:
  bool _internal_has_operation() const;
  public:
  void clear_operation();
  ::proto::SyncdMutation_SyncdOperation operation() const;
  void set_operation(::proto::SyncdMutation_SyncdOperation value);
  private:
  ::proto::SyncdMutation_SyncdOperation _internal_operation() const;
  void _internal_set_operation(::proto::SyncdMutation_SyncdOperation value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncdMutation)
 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_;
    ::proto::SyncdRecord* record_;
    int operation_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdMutations final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdMutations) */ {
 public:
  inline SyncdMutations() : SyncdMutations(nullptr) {}
  ~SyncdMutations() override;
  explicit PROTOBUF_CONSTEXPR SyncdMutations(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdMutations(const SyncdMutations& from);
  SyncdMutations(SyncdMutations&& from) noexcept
    : SyncdMutations() {
    *this = ::std::move(from);
  }

  inline SyncdMutations& operator=(const SyncdMutations& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdMutations& operator=(SyncdMutations&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdMutations& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdMutations* internal_default_instance() {
    return reinterpret_cast<const SyncdMutations*>(
               &_SyncdMutations_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    207;

  friend void swap(SyncdMutations& a, SyncdMutations& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdMutations* 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(SyncdMutations* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdMutations* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdMutations>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdMutations& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdMutations& from) {
    SyncdMutations::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdMutations* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdMutations";
  }
  protected:
  explicit SyncdMutations(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMutationsFieldNumber = 1,
  };
  // repeated .proto.SyncdMutation mutations = 1;
  int mutations_size() const;
  private:
  int _internal_mutations_size() const;
  public:
  void clear_mutations();
  ::proto::SyncdMutation* mutable_mutations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
      mutable_mutations();
  private:
  const ::proto::SyncdMutation& _internal_mutations(int index) const;
  ::proto::SyncdMutation* _internal_add_mutations();
  public:
  const ::proto::SyncdMutation& mutations(int index) const;
  ::proto::SyncdMutation* add_mutations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
      mutations() const;

  // @@protoc_insertion_point(class_scope:proto.SyncdMutations)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation > mutations_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdPatch final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdPatch) */ {
 public:
  inline SyncdPatch() : SyncdPatch(nullptr) {}
  ~SyncdPatch() override;
  explicit PROTOBUF_CONSTEXPR SyncdPatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdPatch(const SyncdPatch& from);
  SyncdPatch(SyncdPatch&& from) noexcept
    : SyncdPatch() {
    *this = ::std::move(from);
  }

  inline SyncdPatch& operator=(const SyncdPatch& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdPatch& operator=(SyncdPatch&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdPatch& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdPatch* internal_default_instance() {
    return reinterpret_cast<const SyncdPatch*>(
               &_SyncdPatch_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    208;

  friend void swap(SyncdPatch& a, SyncdPatch& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdPatch* 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(SyncdPatch* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdPatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdPatch>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdPatch& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdPatch& from) {
    SyncdPatch::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdPatch* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdPatch";
  }
  protected:
  explicit SyncdPatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMutationsFieldNumber = 2,
    kSnapshotMacFieldNumber = 4,
    kPatchMacFieldNumber = 5,
    kVersionFieldNumber = 1,
    kExternalMutationsFieldNumber = 3,
    kKeyIdFieldNumber = 6,
    kExitCodeFieldNumber = 7,
    kDeviceIndexFieldNumber = 8,
  };
  // repeated .proto.SyncdMutation mutations = 2;
  int mutations_size() const;
  private:
  int _internal_mutations_size() const;
  public:
  void clear_mutations();
  ::proto::SyncdMutation* mutable_mutations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
      mutable_mutations();
  private:
  const ::proto::SyncdMutation& _internal_mutations(int index) const;
  ::proto::SyncdMutation* _internal_add_mutations();
  public:
  const ::proto::SyncdMutation& mutations(int index) const;
  ::proto::SyncdMutation* add_mutations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
      mutations() const;

  // optional bytes snapshotMac = 4;
  bool has_snapshotmac() const;
  private:
  bool _internal_has_snapshotmac() const;
  public:
  void clear_snapshotmac();
  const std::string& snapshotmac() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_snapshotmac(ArgT0&& arg0, ArgT... args);
  std::string* mutable_snapshotmac();
  PROTOBUF_NODISCARD std::string* release_snapshotmac();
  void set_allocated_snapshotmac(std::string* snapshotmac);
  private:
  const std::string& _internal_snapshotmac() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_snapshotmac(const std::string& value);
  std::string* _internal_mutable_snapshotmac();
  public:

  // optional bytes patchMac = 5;
  bool has_patchmac() const;
  private:
  bool _internal_has_patchmac() const;
  public:
  void clear_patchmac();
  const std::string& patchmac() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_patchmac(ArgT0&& arg0, ArgT... args);
  std::string* mutable_patchmac();
  PROTOBUF_NODISCARD std::string* release_patchmac();
  void set_allocated_patchmac(std::string* patchmac);
  private:
  const std::string& _internal_patchmac() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_patchmac(const std::string& value);
  std::string* _internal_mutable_patchmac();
  public:

  // optional .proto.SyncdVersion version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const ::proto::SyncdVersion& version() const;
  PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version();
  ::proto::SyncdVersion* mutable_version();
  void set_allocated_version(::proto::SyncdVersion* version);
  private:
  const ::proto::SyncdVersion& _internal_version() const;
  ::proto::SyncdVersion* _internal_mutable_version();
  public:
  void unsafe_arena_set_allocated_version(
      ::proto::SyncdVersion* version);
  ::proto::SyncdVersion* unsafe_arena_release_version();

  // optional .proto.ExternalBlobReference externalMutations = 3;
  bool has_externalmutations() const;
  private:
  bool _internal_has_externalmutations() const;
  public:
  void clear_externalmutations();
  const ::proto::ExternalBlobReference& externalmutations() const;
  PROTOBUF_NODISCARD ::proto::ExternalBlobReference* release_externalmutations();
  ::proto::ExternalBlobReference* mutable_externalmutations();
  void set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations);
  private:
  const ::proto::ExternalBlobReference& _internal_externalmutations() const;
  ::proto::ExternalBlobReference* _internal_mutable_externalmutations();
  public:
  void unsafe_arena_set_allocated_externalmutations(
      ::proto::ExternalBlobReference* externalmutations);
  ::proto::ExternalBlobReference* unsafe_arena_release_externalmutations();

  // optional .proto.KeyId keyId = 6;
  bool has_keyid() const;
  private:
  bool _internal_has_keyid() const;
  public:
  void clear_keyid();
  const ::proto::KeyId& keyid() const;
  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
  ::proto::KeyId* mutable_keyid();
  void set_allocated_keyid(::proto::KeyId* keyid);
  private:
  const ::proto::KeyId& _internal_keyid() const;
  ::proto::KeyId* _internal_mutable_keyid();
  public:
  void unsafe_arena_set_allocated_keyid(
      ::proto::KeyId* keyid);
  ::proto::KeyId* unsafe_arena_release_keyid();

  // optional .proto.ExitCode exitCode = 7;
  bool has_exitcode() const;
  private:
  bool _internal_has_exitcode() const;
  public:
  void clear_exitcode();
  const ::proto::ExitCode& exitcode() const;
  PROTOBUF_NODISCARD ::proto::ExitCode* release_exitcode();
  ::proto::ExitCode* mutable_exitcode();
  void set_allocated_exitcode(::proto::ExitCode* exitcode);
  private:
  const ::proto::ExitCode& _internal_exitcode() const;
  ::proto::ExitCode* _internal_mutable_exitcode();
  public:
  void unsafe_arena_set_allocated_exitcode(
      ::proto::ExitCode* exitcode);
  ::proto::ExitCode* unsafe_arena_release_exitcode();

  // optional uint32 deviceIndex = 8;
  bool has_deviceindex() const;
  private:
  bool _internal_has_deviceindex() const;
  public:
  void clear_deviceindex();
  uint32_t deviceindex() const;
  void set_deviceindex(uint32_t value);
  private:
  uint32_t _internal_deviceindex() const;
  void _internal_set_deviceindex(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncdPatch)
 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< ::proto::SyncdMutation > mutations_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshotmac_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr patchmac_;
    ::proto::SyncdVersion* version_;
    ::proto::ExternalBlobReference* externalmutations_;
    ::proto::KeyId* keyid_;
    ::proto::ExitCode* exitcode_;
    uint32_t deviceindex_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdRecord final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdRecord) */ {
 public:
  inline SyncdRecord() : SyncdRecord(nullptr) {}
  ~SyncdRecord() override;
  explicit PROTOBUF_CONSTEXPR SyncdRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdRecord(const SyncdRecord& from);
  SyncdRecord(SyncdRecord&& from) noexcept
    : SyncdRecord() {
    *this = ::std::move(from);
  }

  inline SyncdRecord& operator=(const SyncdRecord& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdRecord& operator=(SyncdRecord&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdRecord& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdRecord* internal_default_instance() {
    return reinterpret_cast<const SyncdRecord*>(
               &_SyncdRecord_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    209;

  friend void swap(SyncdRecord& a, SyncdRecord& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdRecord* 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(SyncdRecord* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdRecord>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdRecord& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdRecord& from) {
    SyncdRecord::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdRecord* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdRecord";
  }
  protected:
  explicit SyncdRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIndexFieldNumber = 1,
    kValueFieldNumber = 2,
    kKeyIdFieldNumber = 3,
  };
  // optional .proto.SyncdIndex index = 1;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  const ::proto::SyncdIndex& index() const;
  PROTOBUF_NODISCARD ::proto::SyncdIndex* release_index();
  ::proto::SyncdIndex* mutable_index();
  void set_allocated_index(::proto::SyncdIndex* index);
  private:
  const ::proto::SyncdIndex& _internal_index() const;
  ::proto::SyncdIndex* _internal_mutable_index();
  public:
  void unsafe_arena_set_allocated_index(
      ::proto::SyncdIndex* index);
  ::proto::SyncdIndex* unsafe_arena_release_index();

  // optional .proto.SyncdValue value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::proto::SyncdValue& value() const;
  PROTOBUF_NODISCARD ::proto::SyncdValue* release_value();
  ::proto::SyncdValue* mutable_value();
  void set_allocated_value(::proto::SyncdValue* value);
  private:
  const ::proto::SyncdValue& _internal_value() const;
  ::proto::SyncdValue* _internal_mutable_value();
  public:
  void unsafe_arena_set_allocated_value(
      ::proto::SyncdValue* value);
  ::proto::SyncdValue* unsafe_arena_release_value();

  // optional .proto.KeyId keyId = 3;
  bool has_keyid() const;
  private:
  bool _internal_has_keyid() const;
  public:
  void clear_keyid();
  const ::proto::KeyId& keyid() const;
  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
  ::proto::KeyId* mutable_keyid();
  void set_allocated_keyid(::proto::KeyId* keyid);
  private:
  const ::proto::KeyId& _internal_keyid() const;
  ::proto::KeyId* _internal_mutable_keyid();
  public:
  void unsafe_arena_set_allocated_keyid(
      ::proto::KeyId* keyid);
  ::proto::KeyId* unsafe_arena_release_keyid();

  // @@protoc_insertion_point(class_scope:proto.SyncdRecord)
 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_;
    ::proto::SyncdIndex* index_;
    ::proto::SyncdValue* value_;
    ::proto::KeyId* keyid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdSnapshot final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdSnapshot) */ {
 public:
  inline SyncdSnapshot() : SyncdSnapshot(nullptr) {}
  ~SyncdSnapshot() override;
  explicit PROTOBUF_CONSTEXPR SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdSnapshot(const SyncdSnapshot& from);
  SyncdSnapshot(SyncdSnapshot&& from) noexcept
    : SyncdSnapshot() {
    *this = ::std::move(from);
  }

  inline SyncdSnapshot& operator=(const SyncdSnapshot& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdSnapshot& operator=(SyncdSnapshot&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdSnapshot& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdSnapshot* internal_default_instance() {
    return reinterpret_cast<const SyncdSnapshot*>(
               &_SyncdSnapshot_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    210;

  friend void swap(SyncdSnapshot& a, SyncdSnapshot& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdSnapshot* 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(SyncdSnapshot* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdSnapshot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdSnapshot>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdSnapshot& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdSnapshot& from) {
    SyncdSnapshot::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdSnapshot* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdSnapshot";
  }
  protected:
  explicit SyncdSnapshot(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRecordsFieldNumber = 2,
    kMacFieldNumber = 3,
    kVersionFieldNumber = 1,
    kKeyIdFieldNumber = 4,
  };
  // repeated .proto.SyncdRecord records = 2;
  int records_size() const;
  private:
  int _internal_records_size() const;
  public:
  void clear_records();
  ::proto::SyncdRecord* mutable_records(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >*
      mutable_records();
  private:
  const ::proto::SyncdRecord& _internal_records(int index) const;
  ::proto::SyncdRecord* _internal_add_records();
  public:
  const ::proto::SyncdRecord& records(int index) const;
  ::proto::SyncdRecord* add_records();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >&
      records() const;

  // optional bytes mac = 3;
  bool has_mac() const;
  private:
  bool _internal_has_mac() const;
  public:
  void clear_mac();
  const std::string& mac() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mac(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mac();
  PROTOBUF_NODISCARD std::string* release_mac();
  void set_allocated_mac(std::string* mac);
  private:
  const std::string& _internal_mac() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac(const std::string& value);
  std::string* _internal_mutable_mac();
  public:

  // optional .proto.SyncdVersion version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  const ::proto::SyncdVersion& version() const;
  PROTOBUF_NODISCARD ::proto::SyncdVersion* release_version();
  ::proto::SyncdVersion* mutable_version();
  void set_allocated_version(::proto::SyncdVersion* version);
  private:
  const ::proto::SyncdVersion& _internal_version() const;
  ::proto::SyncdVersion* _internal_mutable_version();
  public:
  void unsafe_arena_set_allocated_version(
      ::proto::SyncdVersion* version);
  ::proto::SyncdVersion* unsafe_arena_release_version();

  // optional .proto.KeyId keyId = 4;
  bool has_keyid() const;
  private:
  bool _internal_has_keyid() const;
  public:
  void clear_keyid();
  const ::proto::KeyId& keyid() const;
  PROTOBUF_NODISCARD ::proto::KeyId* release_keyid();
  ::proto::KeyId* mutable_keyid();
  void set_allocated_keyid(::proto::KeyId* keyid);
  private:
  const ::proto::KeyId& _internal_keyid() const;
  ::proto::KeyId* _internal_mutable_keyid();
  public:
  void unsafe_arena_set_allocated_keyid(
      ::proto::KeyId* keyid);
  ::proto::KeyId* unsafe_arena_release_keyid();

  // @@protoc_insertion_point(class_scope:proto.SyncdSnapshot)
 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< ::proto::SyncdRecord > records_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_;
    ::proto::SyncdVersion* version_;
    ::proto::KeyId* keyid_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdValue final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdValue) */ {
 public:
  inline SyncdValue() : SyncdValue(nullptr) {}
  ~SyncdValue() override;
  explicit PROTOBUF_CONSTEXPR SyncdValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdValue(const SyncdValue& from);
  SyncdValue(SyncdValue&& from) noexcept
    : SyncdValue() {
    *this = ::std::move(from);
  }

  inline SyncdValue& operator=(const SyncdValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdValue& operator=(SyncdValue&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdValue* internal_default_instance() {
    return reinterpret_cast<const SyncdValue*>(
               &_SyncdValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    211;

  friend void swap(SyncdValue& a, SyncdValue& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdValue* 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(SyncdValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdValue>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdValue& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdValue& from) {
    SyncdValue::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdValue* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdValue";
  }
  protected:
  explicit SyncdValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBlobFieldNumber = 1,
  };
  // optional bytes blob = 1;
  bool has_blob() const;
  private:
  bool _internal_has_blob() const;
  public:
  void clear_blob();
  const std::string& blob() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_blob(ArgT0&& arg0, ArgT... args);
  std::string* mutable_blob();
  PROTOBUF_NODISCARD std::string* release_blob();
  void set_allocated_blob(std::string* blob);
  private:
  const std::string& _internal_blob() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blob(const std::string& value);
  std::string* _internal_mutable_blob();
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncdValue)
 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 blob_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class SyncdVersion final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.SyncdVersion) */ {
 public:
  inline SyncdVersion() : SyncdVersion(nullptr) {}
  ~SyncdVersion() override;
  explicit PROTOBUF_CONSTEXPR SyncdVersion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SyncdVersion(const SyncdVersion& from);
  SyncdVersion(SyncdVersion&& from) noexcept
    : SyncdVersion() {
    *this = ::std::move(from);
  }

  inline SyncdVersion& operator=(const SyncdVersion& from) {
    CopyFrom(from);
    return *this;
  }
  inline SyncdVersion& operator=(SyncdVersion&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SyncdVersion& default_instance() {
    return *internal_default_instance();
  }
  static inline const SyncdVersion* internal_default_instance() {
    return reinterpret_cast<const SyncdVersion*>(
               &_SyncdVersion_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    212;

  friend void swap(SyncdVersion& a, SyncdVersion& b) {
    a.Swap(&b);
  }
  inline void Swap(SyncdVersion* 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(SyncdVersion* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  SyncdVersion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SyncdVersion>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SyncdVersion& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const SyncdVersion& from) {
    SyncdVersion::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SyncdVersion* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.SyncdVersion";
  }
  protected:
  explicit SyncdVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kVersionFieldNumber = 1,
  };
  // optional uint64 version = 1;
  bool has_version() const;
  private:
  bool _internal_has_version() const;
  public:
  void clear_version();
  uint64_t version() const;
  void set_version(uint64_t value);
  private:
  uint64_t _internal_version() const;
  void _internal_set_version(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.SyncdVersion)
 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 version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class TemplateButton_CallButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.CallButton) */ {
 public:
  inline TemplateButton_CallButton() : TemplateButton_CallButton(nullptr) {}
  ~TemplateButton_CallButton() override;
  explicit PROTOBUF_CONSTEXPR TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateButton_CallButton(const TemplateButton_CallButton& from);
  TemplateButton_CallButton(TemplateButton_CallButton&& from) noexcept
    : TemplateButton_CallButton() {
    *this = ::std::move(from);
  }

  inline TemplateButton_CallButton& operator=(const TemplateButton_CallButton& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateButton_CallButton& operator=(TemplateButton_CallButton&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateButton_CallButton& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateButton_CallButton* internal_default_instance() {
    return reinterpret_cast<const TemplateButton_CallButton*>(
               &_TemplateButton_CallButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    213;

  friend void swap(TemplateButton_CallButton& a, TemplateButton_CallButton& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateButton_CallButton* 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(TemplateButton_CallButton* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateButton_CallButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateButton_CallButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateButton_CallButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TemplateButton_CallButton& from) {
    TemplateButton_CallButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateButton_CallButton* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.TemplateButton.CallButton";
  }
  protected:
  explicit TemplateButton_CallButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDisplayTextFieldNumber = 1,
    kPhoneNumberFieldNumber = 2,
  };
  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
  public:
  void unsafe_arena_set_allocated_displaytext(
      ::proto::Message_HighlyStructuredMessage* displaytext);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();

  // optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
  bool has_phonenumber() const;
  private:
  bool _internal_has_phonenumber() const;
  public:
  void clear_phonenumber();
  const ::proto::Message_HighlyStructuredMessage& phonenumber() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_phonenumber();
  ::proto::Message_HighlyStructuredMessage* mutable_phonenumber();
  void set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_phonenumber() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_phonenumber();
  public:
  void unsafe_arena_set_allocated_phonenumber(
      ::proto::Message_HighlyStructuredMessage* phonenumber);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_phonenumber();

  // @@protoc_insertion_point(class_scope:proto.TemplateButton.CallButton)
 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_;
    ::proto::Message_HighlyStructuredMessage* displaytext_;
    ::proto::Message_HighlyStructuredMessage* phonenumber_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class TemplateButton_QuickReplyButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.QuickReplyButton) */ {
 public:
  inline TemplateButton_QuickReplyButton() : TemplateButton_QuickReplyButton(nullptr) {}
  ~TemplateButton_QuickReplyButton() override;
  explicit PROTOBUF_CONSTEXPR TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateButton_QuickReplyButton(const TemplateButton_QuickReplyButton& from);
  TemplateButton_QuickReplyButton(TemplateButton_QuickReplyButton&& from) noexcept
    : TemplateButton_QuickReplyButton() {
    *this = ::std::move(from);
  }

  inline TemplateButton_QuickReplyButton& operator=(const TemplateButton_QuickReplyButton& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateButton_QuickReplyButton& operator=(TemplateButton_QuickReplyButton&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateButton_QuickReplyButton& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateButton_QuickReplyButton* internal_default_instance() {
    return reinterpret_cast<const TemplateButton_QuickReplyButton*>(
               &_TemplateButton_QuickReplyButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    214;

  friend void swap(TemplateButton_QuickReplyButton& a, TemplateButton_QuickReplyButton& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateButton_QuickReplyButton* 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(TemplateButton_QuickReplyButton* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateButton_QuickReplyButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateButton_QuickReplyButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateButton_QuickReplyButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TemplateButton_QuickReplyButton& from) {
    TemplateButton_QuickReplyButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateButton_QuickReplyButton* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.TemplateButton.QuickReplyButton";
  }
  protected:
  explicit TemplateButton_QuickReplyButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIdFieldNumber = 2,
    kDisplayTextFieldNumber = 1,
  };
  // optional string id = 2;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
  public:
  void unsafe_arena_set_allocated_displaytext(
      ::proto::Message_HighlyStructuredMessage* displaytext);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();

  // @@protoc_insertion_point(class_scope:proto.TemplateButton.QuickReplyButton)
 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 id_;
    ::proto::Message_HighlyStructuredMessage* displaytext_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class TemplateButton_URLButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton.URLButton) */ {
 public:
  inline TemplateButton_URLButton() : TemplateButton_URLButton(nullptr) {}
  ~TemplateButton_URLButton() override;
  explicit PROTOBUF_CONSTEXPR TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateButton_URLButton(const TemplateButton_URLButton& from);
  TemplateButton_URLButton(TemplateButton_URLButton&& from) noexcept
    : TemplateButton_URLButton() {
    *this = ::std::move(from);
  }

  inline TemplateButton_URLButton& operator=(const TemplateButton_URLButton& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateButton_URLButton& operator=(TemplateButton_URLButton&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateButton_URLButton& default_instance() {
    return *internal_default_instance();
  }
  static inline const TemplateButton_URLButton* internal_default_instance() {
    return reinterpret_cast<const TemplateButton_URLButton*>(
               &_TemplateButton_URLButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    215;

  friend void swap(TemplateButton_URLButton& a, TemplateButton_URLButton& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateButton_URLButton* 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(TemplateButton_URLButton* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateButton_URLButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateButton_URLButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateButton_URLButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TemplateButton_URLButton& from) {
    TemplateButton_URLButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateButton_URLButton* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.TemplateButton.URLButton";
  }
  protected:
  explicit TemplateButton_URLButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDisplayTextFieldNumber = 1,
    kUrlFieldNumber = 2,
  };
  // optional .proto.Message.HighlyStructuredMessage displayText = 1;
  bool has_displaytext() const;
  private:
  bool _internal_has_displaytext() const;
  public:
  void clear_displaytext();
  const ::proto::Message_HighlyStructuredMessage& displaytext() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_displaytext();
  ::proto::Message_HighlyStructuredMessage* mutable_displaytext();
  void set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_displaytext() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_displaytext();
  public:
  void unsafe_arena_set_allocated_displaytext(
      ::proto::Message_HighlyStructuredMessage* displaytext);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_displaytext();

  // optional .proto.Message.HighlyStructuredMessage url = 2;
  bool has_url() const;
  private:
  bool _internal_has_url() const;
  public:
  void clear_url();
  const ::proto::Message_HighlyStructuredMessage& url() const;
  PROTOBUF_NODISCARD ::proto::Message_HighlyStructuredMessage* release_url();
  ::proto::Message_HighlyStructuredMessage* mutable_url();
  void set_allocated_url(::proto::Message_HighlyStructuredMessage* url);
  private:
  const ::proto::Message_HighlyStructuredMessage& _internal_url() const;
  ::proto::Message_HighlyStructuredMessage* _internal_mutable_url();
  public:
  void unsafe_arena_set_allocated_url(
      ::proto::Message_HighlyStructuredMessage* url);
  ::proto::Message_HighlyStructuredMessage* unsafe_arena_release_url();

  // @@protoc_insertion_point(class_scope:proto.TemplateButton.URLButton)
 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_;
    ::proto::Message_HighlyStructuredMessage* displaytext_;
    ::proto::Message_HighlyStructuredMessage* url_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class TemplateButton final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.TemplateButton) */ {
 public:
  inline TemplateButton() : TemplateButton(nullptr) {}
  ~TemplateButton() override;
  explicit PROTOBUF_CONSTEXPR TemplateButton(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TemplateButton(const TemplateButton& from);
  TemplateButton(TemplateButton&& from) noexcept
    : TemplateButton() {
    *this = ::std::move(from);
  }

  inline TemplateButton& operator=(const TemplateButton& from) {
    CopyFrom(from);
    return *this;
  }
  inline TemplateButton& operator=(TemplateButton&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TemplateButton& default_instance() {
    return *internal_default_instance();
  }
  enum ButtonCase {
    kQuickReplyButton = 1,
    kUrlButton = 2,
    kCallButton = 3,
    BUTTON_NOT_SET = 0,
  };

  static inline const TemplateButton* internal_default_instance() {
    return reinterpret_cast<const TemplateButton*>(
               &_TemplateButton_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    216;

  friend void swap(TemplateButton& a, TemplateButton& b) {
    a.Swap(&b);
  }
  inline void Swap(TemplateButton* 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(TemplateButton* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  TemplateButton* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TemplateButton>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TemplateButton& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const TemplateButton& from) {
    TemplateButton::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TemplateButton* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.TemplateButton";
  }
  protected:
  explicit TemplateButton(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TemplateButton_CallButton CallButton;
  typedef TemplateButton_QuickReplyButton QuickReplyButton;
  typedef TemplateButton_URLButton URLButton;

  // accessors -------------------------------------------------------

  enum : int {
    kIndexFieldNumber = 4,
    kQuickReplyButtonFieldNumber = 1,
    kUrlButtonFieldNumber = 2,
    kCallButtonFieldNumber = 3,
  };
  // optional uint32 index = 4;
  bool has_index() const;
  private:
  bool _internal_has_index() const;
  public:
  void clear_index();
  uint32_t index() const;
  void set_index(uint32_t value);
  private:
  uint32_t _internal_index() const;
  void _internal_set_index(uint32_t value);
  public:

  // .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
  bool has_quickreplybutton() const;
  private:
  bool _internal_has_quickreplybutton() const;
  public:
  void clear_quickreplybutton();
  const ::proto::TemplateButton_QuickReplyButton& quickreplybutton() const;
  PROTOBUF_NODISCARD ::proto::TemplateButton_QuickReplyButton* release_quickreplybutton();
  ::proto::TemplateButton_QuickReplyButton* mutable_quickreplybutton();
  void set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton);
  private:
  const ::proto::TemplateButton_QuickReplyButton& _internal_quickreplybutton() const;
  ::proto::TemplateButton_QuickReplyButton* _internal_mutable_quickreplybutton();
  public:
  void unsafe_arena_set_allocated_quickreplybutton(
      ::proto::TemplateButton_QuickReplyButton* quickreplybutton);
  ::proto::TemplateButton_QuickReplyButton* unsafe_arena_release_quickreplybutton();

  // .proto.TemplateButton.URLButton urlButton = 2;
  bool has_urlbutton() const;
  private:
  bool _internal_has_urlbutton() const;
  public:
  void clear_urlbutton();
  const ::proto::TemplateButton_URLButton& urlbutton() const;
  PROTOBUF_NODISCARD ::proto::TemplateButton_URLButton* release_urlbutton();
  ::proto::TemplateButton_URLButton* mutable_urlbutton();
  void set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton);
  private:
  const ::proto::TemplateButton_URLButton& _internal_urlbutton() const;
  ::proto::TemplateButton_URLButton* _internal_mutable_urlbutton();
  public:
  void unsafe_arena_set_allocated_urlbutton(
      ::proto::TemplateButton_URLButton* urlbutton);
  ::proto::TemplateButton_URLButton* unsafe_arena_release_urlbutton();

  // .proto.TemplateButton.CallButton callButton = 3;
  bool has_callbutton() const;
  private:
  bool _internal_has_callbutton() const;
  public:
  void clear_callbutton();
  const ::proto::TemplateButton_CallButton& callbutton() const;
  PROTOBUF_NODISCARD ::proto::TemplateButton_CallButton* release_callbutton();
  ::proto::TemplateButton_CallButton* mutable_callbutton();
  void set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton);
  private:
  const ::proto::TemplateButton_CallButton& _internal_callbutton() const;
  ::proto::TemplateButton_CallButton* _internal_mutable_callbutton();
  public:
  void unsafe_arena_set_allocated_callbutton(
      ::proto::TemplateButton_CallButton* callbutton);
  ::proto::TemplateButton_CallButton* unsafe_arena_release_callbutton();

  void clear_button();
  ButtonCase button_case() const;
  // @@protoc_insertion_point(class_scope:proto.TemplateButton)
 private:
  class _Internal;
  void set_has_quickreplybutton();
  void set_has_urlbutton();
  void set_has_callbutton();

  inline bool has_button() const;
  inline void clear_has_button();

  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_;
    uint32_t index_;
    union ButtonUnion {
      constexpr ButtonUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::proto::TemplateButton_QuickReplyButton* quickreplybutton_;
      ::proto::TemplateButton_URLButton* urlbutton_;
      ::proto::TemplateButton_CallButton* callbutton_;
    } button_;
    uint32_t _oneof_case_[1];

  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class UserReceipt final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.UserReceipt) */ {
 public:
  inline UserReceipt() : UserReceipt(nullptr) {}
  ~UserReceipt() override;
  explicit PROTOBUF_CONSTEXPR UserReceipt(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  UserReceipt(const UserReceipt& from);
  UserReceipt(UserReceipt&& from) noexcept
    : UserReceipt() {
    *this = ::std::move(from);
  }

  inline UserReceipt& operator=(const UserReceipt& from) {
    CopyFrom(from);
    return *this;
  }
  inline UserReceipt& operator=(UserReceipt&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const UserReceipt& default_instance() {
    return *internal_default_instance();
  }
  static inline const UserReceipt* internal_default_instance() {
    return reinterpret_cast<const UserReceipt*>(
               &_UserReceipt_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    217;

  friend void swap(UserReceipt& a, UserReceipt& b) {
    a.Swap(&b);
  }
  inline void Swap(UserReceipt* 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(UserReceipt* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  UserReceipt* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<UserReceipt>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const UserReceipt& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const UserReceipt& from) {
    UserReceipt::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UserReceipt* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.UserReceipt";
  }
  protected:
  explicit UserReceipt(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPendingDeviceJidFieldNumber = 5,
    kDeliveredDeviceJidFieldNumber = 6,
    kUserJidFieldNumber = 1,
    kReceiptTimestampFieldNumber = 2,
    kReadTimestampFieldNumber = 3,
    kPlayedTimestampFieldNumber = 4,
  };
  // repeated string pendingDeviceJid = 5;
  int pendingdevicejid_size() const;
  private:
  int _internal_pendingdevicejid_size() const;
  public:
  void clear_pendingdevicejid();
  const std::string& pendingdevicejid(int index) const;
  std::string* mutable_pendingdevicejid(int index);
  void set_pendingdevicejid(int index, const std::string& value);
  void set_pendingdevicejid(int index, std::string&& value);
  void set_pendingdevicejid(int index, const char* value);
  void set_pendingdevicejid(int index, const char* value, size_t size);
  std::string* add_pendingdevicejid();
  void add_pendingdevicejid(const std::string& value);
  void add_pendingdevicejid(std::string&& value);
  void add_pendingdevicejid(const char* value);
  void add_pendingdevicejid(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& pendingdevicejid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_pendingdevicejid();
  private:
  const std::string& _internal_pendingdevicejid(int index) const;
  std::string* _internal_add_pendingdevicejid();
  public:

  // repeated string deliveredDeviceJid = 6;
  int delivereddevicejid_size() const;
  private:
  int _internal_delivereddevicejid_size() const;
  public:
  void clear_delivereddevicejid();
  const std::string& delivereddevicejid(int index) const;
  std::string* mutable_delivereddevicejid(int index);
  void set_delivereddevicejid(int index, const std::string& value);
  void set_delivereddevicejid(int index, std::string&& value);
  void set_delivereddevicejid(int index, const char* value);
  void set_delivereddevicejid(int index, const char* value, size_t size);
  std::string* add_delivereddevicejid();
  void add_delivereddevicejid(const std::string& value);
  void add_delivereddevicejid(std::string&& value);
  void add_delivereddevicejid(const char* value);
  void add_delivereddevicejid(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& delivereddevicejid() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_delivereddevicejid();
  private:
  const std::string& _internal_delivereddevicejid(int index) const;
  std::string* _internal_add_delivereddevicejid();
  public:

  // required string userJid = 1;
  bool has_userjid() const;
  private:
  bool _internal_has_userjid() const;
  public:
  void clear_userjid();
  const std::string& userjid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_userjid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_userjid();
  PROTOBUF_NODISCARD std::string* release_userjid();
  void set_allocated_userjid(std::string* userjid);
  private:
  const std::string& _internal_userjid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_userjid(const std::string& value);
  std::string* _internal_mutable_userjid();
  public:

  // optional int64 receiptTimestamp = 2;
  bool has_receipttimestamp() const;
  private:
  bool _internal_has_receipttimestamp() const;
  public:
  void clear_receipttimestamp();
  int64_t receipttimestamp() const;
  void set_receipttimestamp(int64_t value);
  private:
  int64_t _internal_receipttimestamp() const;
  void _internal_set_receipttimestamp(int64_t value);
  public:

  // optional int64 readTimestamp = 3;
  bool has_readtimestamp() const;
  private:
  bool _internal_has_readtimestamp() const;
  public:
  void clear_readtimestamp();
  int64_t readtimestamp() const;
  void set_readtimestamp(int64_t value);
  private:
  int64_t _internal_readtimestamp() const;
  void _internal_set_readtimestamp(int64_t value);
  public:

  // optional int64 playedTimestamp = 4;
  bool has_playedtimestamp() const;
  private:
  bool _internal_has_playedtimestamp() const;
  public:
  void clear_playedtimestamp();
  int64_t playedtimestamp() const;
  void set_playedtimestamp(int64_t value);
  private:
  int64_t _internal_playedtimestamp() const;
  void _internal_set_playedtimestamp(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.UserReceipt)
 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> pendingdevicejid_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> delivereddevicejid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr userjid_;
    int64_t receipttimestamp_;
    int64_t readtimestamp_;
    int64_t playedtimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class VerifiedNameCertificate_Details final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate.Details) */ {
 public:
  inline VerifiedNameCertificate_Details() : VerifiedNameCertificate_Details(nullptr) {}
  ~VerifiedNameCertificate_Details() override;
  explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  VerifiedNameCertificate_Details(const VerifiedNameCertificate_Details& from);
  VerifiedNameCertificate_Details(VerifiedNameCertificate_Details&& from) noexcept
    : VerifiedNameCertificate_Details() {
    *this = ::std::move(from);
  }

  inline VerifiedNameCertificate_Details& operator=(const VerifiedNameCertificate_Details& from) {
    CopyFrom(from);
    return *this;
  }
  inline VerifiedNameCertificate_Details& operator=(VerifiedNameCertificate_Details&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VerifiedNameCertificate_Details& default_instance() {
    return *internal_default_instance();
  }
  static inline const VerifiedNameCertificate_Details* internal_default_instance() {
    return reinterpret_cast<const VerifiedNameCertificate_Details*>(
               &_VerifiedNameCertificate_Details_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    218;

  friend void swap(VerifiedNameCertificate_Details& a, VerifiedNameCertificate_Details& b) {
    a.Swap(&b);
  }
  inline void Swap(VerifiedNameCertificate_Details* 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(VerifiedNameCertificate_Details* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  VerifiedNameCertificate_Details* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VerifiedNameCertificate_Details>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VerifiedNameCertificate_Details& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const VerifiedNameCertificate_Details& from) {
    VerifiedNameCertificate_Details::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VerifiedNameCertificate_Details* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.VerifiedNameCertificate.Details";
  }
  protected:
  explicit VerifiedNameCertificate_Details(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLocalizedNamesFieldNumber = 8,
    kIssuerFieldNumber = 2,
    kVerifiedNameFieldNumber = 4,
    kSerialFieldNumber = 1,
    kIssueTimeFieldNumber = 10,
  };
  // repeated .proto.LocalizedName localizedNames = 8;
  int localizednames_size() const;
  private:
  int _internal_localizednames_size() const;
  public:
  void clear_localizednames();
  ::proto::LocalizedName* mutable_localizednames(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >*
      mutable_localizednames();
  private:
  const ::proto::LocalizedName& _internal_localizednames(int index) const;
  ::proto::LocalizedName* _internal_add_localizednames();
  public:
  const ::proto::LocalizedName& localizednames(int index) const;
  ::proto::LocalizedName* add_localizednames();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >&
      localizednames() const;

  // optional string issuer = 2;
  bool has_issuer() const;
  private:
  bool _internal_has_issuer() const;
  public:
  void clear_issuer();
  const std::string& issuer() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_issuer(ArgT0&& arg0, ArgT... args);
  std::string* mutable_issuer();
  PROTOBUF_NODISCARD std::string* release_issuer();
  void set_allocated_issuer(std::string* issuer);
  private:
  const std::string& _internal_issuer() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_issuer(const std::string& value);
  std::string* _internal_mutable_issuer();
  public:

  // optional string verifiedName = 4;
  bool has_verifiedname() const;
  private:
  bool _internal_has_verifiedname() const;
  public:
  void clear_verifiedname();
  const std::string& verifiedname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_verifiedname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_verifiedname();
  PROTOBUF_NODISCARD std::string* release_verifiedname();
  void set_allocated_verifiedname(std::string* verifiedname);
  private:
  const std::string& _internal_verifiedname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedname(const std::string& value);
  std::string* _internal_mutable_verifiedname();
  public:

  // optional uint64 serial = 1;
  bool has_serial() const;
  private:
  bool _internal_has_serial() const;
  public:
  void clear_serial();
  uint64_t serial() const;
  void set_serial(uint64_t value);
  private:
  uint64_t _internal_serial() const;
  void _internal_set_serial(uint64_t value);
  public:

  // optional uint64 issueTime = 10;
  bool has_issuetime() const;
  private:
  bool _internal_has_issuetime() const;
  public:
  void clear_issuetime();
  uint64_t issuetime() const;
  void set_issuetime(uint64_t value);
  private:
  uint64_t _internal_issuetime() const;
  void _internal_set_issuetime(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate.Details)
 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< ::proto::LocalizedName > localizednames_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuer_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedname_;
    uint64_t serial_;
    uint64_t issuetime_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class VerifiedNameCertificate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.VerifiedNameCertificate) */ {
 public:
  inline VerifiedNameCertificate() : VerifiedNameCertificate(nullptr) {}
  ~VerifiedNameCertificate() override;
  explicit PROTOBUF_CONSTEXPR VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  VerifiedNameCertificate(const VerifiedNameCertificate& from);
  VerifiedNameCertificate(VerifiedNameCertificate&& from) noexcept
    : VerifiedNameCertificate() {
    *this = ::std::move(from);
  }

  inline VerifiedNameCertificate& operator=(const VerifiedNameCertificate& from) {
    CopyFrom(from);
    return *this;
  }
  inline VerifiedNameCertificate& operator=(VerifiedNameCertificate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const VerifiedNameCertificate& default_instance() {
    return *internal_default_instance();
  }
  static inline const VerifiedNameCertificate* internal_default_instance() {
    return reinterpret_cast<const VerifiedNameCertificate*>(
               &_VerifiedNameCertificate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    219;

  friend void swap(VerifiedNameCertificate& a, VerifiedNameCertificate& b) {
    a.Swap(&b);
  }
  inline void Swap(VerifiedNameCertificate* 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(VerifiedNameCertificate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  VerifiedNameCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<VerifiedNameCertificate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const VerifiedNameCertificate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const VerifiedNameCertificate& from) {
    VerifiedNameCertificate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(VerifiedNameCertificate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.VerifiedNameCertificate";
  }
  protected:
  explicit VerifiedNameCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef VerifiedNameCertificate_Details Details;

  // accessors -------------------------------------------------------

  enum : int {
    kDetailsFieldNumber = 1,
    kSignatureFieldNumber = 2,
    kServerSignatureFieldNumber = 3,
  };
  // optional bytes details = 1;
  bool has_details() const;
  private:
  bool _internal_has_details() const;
  public:
  void clear_details();
  const std::string& details() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_details(ArgT0&& arg0, ArgT... args);
  std::string* mutable_details();
  PROTOBUF_NODISCARD std::string* release_details();
  void set_allocated_details(std::string* details);
  private:
  const std::string& _internal_details() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_details(const std::string& value);
  std::string* _internal_mutable_details();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_NODISCARD std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // optional bytes serverSignature = 3;
  bool has_serversignature() const;
  private:
  bool _internal_has_serversignature() const;
  public:
  void clear_serversignature();
  const std::string& serversignature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_serversignature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_serversignature();
  PROTOBUF_NODISCARD std::string* release_serversignature();
  void set_allocated_serversignature(std::string* serversignature);
  private:
  const std::string& _internal_serversignature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serversignature(const std::string& value);
  std::string* _internal_mutable_serversignature();
  public:

  // @@protoc_insertion_point(class_scope:proto.VerifiedNameCertificate)
 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 details_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serversignature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class WallpaperSettings final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WallpaperSettings) */ {
 public:
  inline WallpaperSettings() : WallpaperSettings(nullptr) {}
  ~WallpaperSettings() override;
  explicit PROTOBUF_CONSTEXPR WallpaperSettings(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  WallpaperSettings(const WallpaperSettings& from);
  WallpaperSettings(WallpaperSettings&& from) noexcept
    : WallpaperSettings() {
    *this = ::std::move(from);
  }

  inline WallpaperSettings& operator=(const WallpaperSettings& from) {
    CopyFrom(from);
    return *this;
  }
  inline WallpaperSettings& operator=(WallpaperSettings&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WallpaperSettings& default_instance() {
    return *internal_default_instance();
  }
  static inline const WallpaperSettings* internal_default_instance() {
    return reinterpret_cast<const WallpaperSettings*>(
               &_WallpaperSettings_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    220;

  friend void swap(WallpaperSettings& a, WallpaperSettings& b) {
    a.Swap(&b);
  }
  inline void Swap(WallpaperSettings* 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(WallpaperSettings* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WallpaperSettings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WallpaperSettings>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WallpaperSettings& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WallpaperSettings& from) {
    WallpaperSettings::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WallpaperSettings* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.WallpaperSettings";
  }
  protected:
  explicit WallpaperSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFilenameFieldNumber = 1,
    kOpacityFieldNumber = 2,
  };
  // optional string filename = 1;
  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 uint32 opacity = 2;
  bool has_opacity() const;
  private:
  bool _internal_has_opacity() const;
  public:
  void clear_opacity();
  uint32_t opacity() const;
  void set_opacity(uint32_t value);
  private:
  uint32_t _internal_opacity() const;
  void _internal_set_opacity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.WallpaperSettings)
 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 filename_;
    uint32_t opacity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class WebFeatures final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebFeatures) */ {
 public:
  inline WebFeatures() : WebFeatures(nullptr) {}
  ~WebFeatures() override;
  explicit PROTOBUF_CONSTEXPR WebFeatures(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  WebFeatures(const WebFeatures& from);
  WebFeatures(WebFeatures&& from) noexcept
    : WebFeatures() {
    *this = ::std::move(from);
  }

  inline WebFeatures& operator=(const WebFeatures& from) {
    CopyFrom(from);
    return *this;
  }
  inline WebFeatures& operator=(WebFeatures&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WebFeatures& default_instance() {
    return *internal_default_instance();
  }
  static inline const WebFeatures* internal_default_instance() {
    return reinterpret_cast<const WebFeatures*>(
               &_WebFeatures_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    221;

  friend void swap(WebFeatures& a, WebFeatures& b) {
    a.Swap(&b);
  }
  inline void Swap(WebFeatures* 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(WebFeatures* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WebFeatures* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WebFeatures>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WebFeatures& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WebFeatures& from) {
    WebFeatures::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WebFeatures* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.WebFeatures";
  }
  protected:
  explicit WebFeatures(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef WebFeatures_Flag Flag;
  static constexpr Flag NOT_STARTED =
    WebFeatures_Flag_NOT_STARTED;
  static constexpr Flag FORCE_UPGRADE =
    WebFeatures_Flag_FORCE_UPGRADE;
  static constexpr Flag DEVELOPMENT =
    WebFeatures_Flag_DEVELOPMENT;
  static constexpr Flag PRODUCTION =
    WebFeatures_Flag_PRODUCTION;
  static inline bool Flag_IsValid(int value) {
    return WebFeatures_Flag_IsValid(value);
  }
  static constexpr Flag Flag_MIN =
    WebFeatures_Flag_Flag_MIN;
  static constexpr Flag Flag_MAX =
    WebFeatures_Flag_Flag_MAX;
  static constexpr int Flag_ARRAYSIZE =
    WebFeatures_Flag_Flag_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flag_descriptor() {
    return WebFeatures_Flag_descriptor();
  }
  template<typename T>
  static inline const std::string& Flag_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flag>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flag_Name.");
    return WebFeatures_Flag_Name(enum_t_value);
  }
  static inline bool Flag_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flag* value) {
    return WebFeatures_Flag_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kLabelsDisplayFieldNumber = 1,
    kVoipIndividualOutgoingFieldNumber = 2,
    kGroupsV3FieldNumber = 3,
    kGroupsV3CreateFieldNumber = 4,
    kChangeNumberV2FieldNumber = 5,
    kQueryStatusV3ThumbnailFieldNumber = 6,
    kLiveLocationsFieldNumber = 7,
    kQueryVnameFieldNumber = 8,
    kVoipIndividualIncomingFieldNumber = 9,
    kQuickRepliesQueryFieldNumber = 10,
    kPaymentsFieldNumber = 11,
    kStickerPackQueryFieldNumber = 12,
    kLiveLocationsFinalFieldNumber = 13,
    kLabelsEditFieldNumber = 14,
    kMediaUploadFieldNumber = 15,
    kMediaUploadRichQuickRepliesFieldNumber = 18,
    kVnameV2FieldNumber = 19,
    kVideoPlaybackUrlFieldNumber = 20,
    kStatusRankingFieldNumber = 21,
    kVoipIndividualVideoFieldNumber = 22,
    kThirdPartyStickersFieldNumber = 23,
    kFrequentlyForwardedSettingFieldNumber = 24,
    kGroupsV4JoinPermissionFieldNumber = 25,
    kRecentStickersFieldNumber = 26,
    kCatalogFieldNumber = 27,
    kStarredStickersFieldNumber = 28,
    kVoipGroupCallFieldNumber = 29,
    kTemplateMessageFieldNumber = 30,
    kTemplateMessageInteractivityFieldNumber = 31,
    kEphemeralMessagesFieldNumber = 32,
    kE2ENotificationSyncFieldNumber = 33,
    kRecentStickersV2FieldNumber = 34,
    kRecentStickersV3FieldNumber = 36,
    kUserNoticeFieldNumber = 37,
    kSupportFieldNumber = 39,
    kGroupUiiCleanupFieldNumber = 40,
    kGroupDogfoodingInternalOnlyFieldNumber = 41,
    kSettingsSyncFieldNumber = 42,
    kArchiveV2FieldNumber = 43,
    kEphemeralAllowGroupMembersFieldNumber = 44,
    kEphemeral24HDurationFieldNumber = 45,
    kMdForceUpgradeFieldNumber = 46,
    kDisappearingModeFieldNumber = 47,
    kExternalMdOptInAvailableFieldNumber = 48,
    kNoDeleteMessageTimeLimitFieldNumber = 49,
  };
  // optional .proto.WebFeatures.Flag labelsDisplay = 1;
  bool has_labelsdisplay() const;
  private:
  bool _internal_has_labelsdisplay() const;
  public:
  void clear_labelsdisplay();
  ::proto::WebFeatures_Flag labelsdisplay() const;
  void set_labelsdisplay(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_labelsdisplay() const;
  void _internal_set_labelsdisplay(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
  bool has_voipindividualoutgoing() const;
  private:
  bool _internal_has_voipindividualoutgoing() const;
  public:
  void clear_voipindividualoutgoing();
  ::proto::WebFeatures_Flag voipindividualoutgoing() const;
  void set_voipindividualoutgoing(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_voipindividualoutgoing() const;
  void _internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag groupsV3 = 3;
  bool has_groupsv3() const;
  private:
  bool _internal_has_groupsv3() const;
  public:
  void clear_groupsv3();
  ::proto::WebFeatures_Flag groupsv3() const;
  void set_groupsv3(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_groupsv3() const;
  void _internal_set_groupsv3(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag groupsV3Create = 4;
  bool has_groupsv3create() const;
  private:
  bool _internal_has_groupsv3create() const;
  public:
  void clear_groupsv3create();
  ::proto::WebFeatures_Flag groupsv3create() const;
  void set_groupsv3create(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_groupsv3create() const;
  void _internal_set_groupsv3create(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag changeNumberV2 = 5;
  bool has_changenumberv2() const;
  private:
  bool _internal_has_changenumberv2() const;
  public:
  void clear_changenumberv2();
  ::proto::WebFeatures_Flag changenumberv2() const;
  void set_changenumberv2(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_changenumberv2() const;
  void _internal_set_changenumberv2(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
  bool has_querystatusv3thumbnail() const;
  private:
  bool _internal_has_querystatusv3thumbnail() const;
  public:
  void clear_querystatusv3thumbnail();
  ::proto::WebFeatures_Flag querystatusv3thumbnail() const;
  void set_querystatusv3thumbnail(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_querystatusv3thumbnail() const;
  void _internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag liveLocations = 7;
  bool has_livelocations() const;
  private:
  bool _internal_has_livelocations() const;
  public:
  void clear_livelocations();
  ::proto::WebFeatures_Flag livelocations() const;
  void set_livelocations(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_livelocations() const;
  void _internal_set_livelocations(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag queryVname = 8;
  bool has_queryvname() const;
  private:
  bool _internal_has_queryvname() const;
  public:
  void clear_queryvname();
  ::proto::WebFeatures_Flag queryvname() const;
  void set_queryvname(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_queryvname() const;
  void _internal_set_queryvname(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
  bool has_voipindividualincoming() const;
  private:
  bool _internal_has_voipindividualincoming() const;
  public:
  void clear_voipindividualincoming();
  ::proto::WebFeatures_Flag voipindividualincoming() const;
  void set_voipindividualincoming(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_voipindividualincoming() const;
  void _internal_set_voipindividualincoming(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
  bool has_quickrepliesquery() const;
  private:
  bool _internal_has_quickrepliesquery() const;
  public:
  void clear_quickrepliesquery();
  ::proto::WebFeatures_Flag quickrepliesquery() const;
  void set_quickrepliesquery(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_quickrepliesquery() const;
  void _internal_set_quickrepliesquery(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag payments = 11;
  bool has_payments() const;
  private:
  bool _internal_has_payments() const;
  public:
  void clear_payments();
  ::proto::WebFeatures_Flag payments() const;
  void set_payments(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_payments() const;
  void _internal_set_payments(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag stickerPackQuery = 12;
  bool has_stickerpackquery() const;
  private:
  bool _internal_has_stickerpackquery() const;
  public:
  void clear_stickerpackquery();
  ::proto::WebFeatures_Flag stickerpackquery() const;
  void set_stickerpackquery(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_stickerpackquery() const;
  void _internal_set_stickerpackquery(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
  bool has_livelocationsfinal() const;
  private:
  bool _internal_has_livelocationsfinal() const;
  public:
  void clear_livelocationsfinal();
  ::proto::WebFeatures_Flag livelocationsfinal() const;
  void set_livelocationsfinal(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_livelocationsfinal() const;
  void _internal_set_livelocationsfinal(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag labelsEdit = 14;
  bool has_labelsedit() const;
  private:
  bool _internal_has_labelsedit() const;
  public:
  void clear_labelsedit();
  ::proto::WebFeatures_Flag labelsedit() const;
  void set_labelsedit(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_labelsedit() const;
  void _internal_set_labelsedit(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag mediaUpload = 15;
  bool has_mediaupload() const;
  private:
  bool _internal_has_mediaupload() const;
  public:
  void clear_mediaupload();
  ::proto::WebFeatures_Flag mediaupload() const;
  void set_mediaupload(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_mediaupload() const;
  void _internal_set_mediaupload(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
  bool has_mediauploadrichquickreplies() const;
  private:
  bool _internal_has_mediauploadrichquickreplies() const;
  public:
  void clear_mediauploadrichquickreplies();
  ::proto::WebFeatures_Flag mediauploadrichquickreplies() const;
  void set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_mediauploadrichquickreplies() const;
  void _internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag vnameV2 = 19;
  bool has_vnamev2() const;
  private:
  bool _internal_has_vnamev2() const;
  public:
  void clear_vnamev2();
  ::proto::WebFeatures_Flag vnamev2() const;
  void set_vnamev2(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_vnamev2() const;
  void _internal_set_vnamev2(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
  bool has_videoplaybackurl() const;
  private:
  bool _internal_has_videoplaybackurl() const;
  public:
  void clear_videoplaybackurl();
  ::proto::WebFeatures_Flag videoplaybackurl() const;
  void set_videoplaybackurl(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_videoplaybackurl() const;
  void _internal_set_videoplaybackurl(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag statusRanking = 21;
  bool has_statusranking() const;
  private:
  bool _internal_has_statusranking() const;
  public:
  void clear_statusranking();
  ::proto::WebFeatures_Flag statusranking() const;
  void set_statusranking(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_statusranking() const;
  void _internal_set_statusranking(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
  bool has_voipindividualvideo() const;
  private:
  bool _internal_has_voipindividualvideo() const;
  public:
  void clear_voipindividualvideo();
  ::proto::WebFeatures_Flag voipindividualvideo() const;
  void set_voipindividualvideo(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_voipindividualvideo() const;
  void _internal_set_voipindividualvideo(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
  bool has_thirdpartystickers() const;
  private:
  bool _internal_has_thirdpartystickers() const;
  public:
  void clear_thirdpartystickers();
  ::proto::WebFeatures_Flag thirdpartystickers() const;
  void set_thirdpartystickers(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_thirdpartystickers() const;
  void _internal_set_thirdpartystickers(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
  bool has_frequentlyforwardedsetting() const;
  private:
  bool _internal_has_frequentlyforwardedsetting() const;
  public:
  void clear_frequentlyforwardedsetting();
  ::proto::WebFeatures_Flag frequentlyforwardedsetting() const;
  void set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_frequentlyforwardedsetting() const;
  void _internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
  bool has_groupsv4joinpermission() const;
  private:
  bool _internal_has_groupsv4joinpermission() const;
  public:
  void clear_groupsv4joinpermission();
  ::proto::WebFeatures_Flag groupsv4joinpermission() const;
  void set_groupsv4joinpermission(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_groupsv4joinpermission() const;
  void _internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag recentStickers = 26;
  bool has_recentstickers() const;
  private:
  bool _internal_has_recentstickers() const;
  public:
  void clear_recentstickers();
  ::proto::WebFeatures_Flag recentstickers() const;
  void set_recentstickers(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_recentstickers() const;
  void _internal_set_recentstickers(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag catalog = 27;
  bool has_catalog() const;
  private:
  bool _internal_has_catalog() const;
  public:
  void clear_catalog();
  ::proto::WebFeatures_Flag catalog() const;
  void set_catalog(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_catalog() const;
  void _internal_set_catalog(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag starredStickers = 28;
  bool has_starredstickers() const;
  private:
  bool _internal_has_starredstickers() const;
  public:
  void clear_starredstickers();
  ::proto::WebFeatures_Flag starredstickers() const;
  void set_starredstickers(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_starredstickers() const;
  void _internal_set_starredstickers(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag voipGroupCall = 29;
  bool has_voipgroupcall() const;
  private:
  bool _internal_has_voipgroupcall() const;
  public:
  void clear_voipgroupcall();
  ::proto::WebFeatures_Flag voipgroupcall() const;
  void set_voipgroupcall(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_voipgroupcall() const;
  void _internal_set_voipgroupcall(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag templateMessage = 30;
  bool has_templatemessage() const;
  private:
  bool _internal_has_templatemessage() const;
  public:
  void clear_templatemessage();
  ::proto::WebFeatures_Flag templatemessage() const;
  void set_templatemessage(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_templatemessage() const;
  void _internal_set_templatemessage(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
  bool has_templatemessageinteractivity() const;
  private:
  bool _internal_has_templatemessageinteractivity() const;
  public:
  void clear_templatemessageinteractivity();
  ::proto::WebFeatures_Flag templatemessageinteractivity() const;
  void set_templatemessageinteractivity(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_templatemessageinteractivity() const;
  void _internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag ephemeralMessages = 32;
  bool has_ephemeralmessages() const;
  private:
  bool _internal_has_ephemeralmessages() const;
  public:
  void clear_ephemeralmessages();
  ::proto::WebFeatures_Flag ephemeralmessages() const;
  void set_ephemeralmessages(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_ephemeralmessages() const;
  void _internal_set_ephemeralmessages(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
  bool has_e2enotificationsync() const;
  private:
  bool _internal_has_e2enotificationsync() const;
  public:
  void clear_e2enotificationsync();
  ::proto::WebFeatures_Flag e2enotificationsync() const;
  void set_e2enotificationsync(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_e2enotificationsync() const;
  void _internal_set_e2enotificationsync(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag recentStickersV2 = 34;
  bool has_recentstickersv2() const;
  private:
  bool _internal_has_recentstickersv2() const;
  public:
  void clear_recentstickersv2();
  ::proto::WebFeatures_Flag recentstickersv2() const;
  void set_recentstickersv2(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_recentstickersv2() const;
  void _internal_set_recentstickersv2(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag recentStickersV3 = 36;
  bool has_recentstickersv3() const;
  private:
  bool _internal_has_recentstickersv3() const;
  public:
  void clear_recentstickersv3();
  ::proto::WebFeatures_Flag recentstickersv3() const;
  void set_recentstickersv3(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_recentstickersv3() const;
  void _internal_set_recentstickersv3(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag userNotice = 37;
  bool has_usernotice() const;
  private:
  bool _internal_has_usernotice() const;
  public:
  void clear_usernotice();
  ::proto::WebFeatures_Flag usernotice() const;
  void set_usernotice(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_usernotice() const;
  void _internal_set_usernotice(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag support = 39;
  bool has_support() const;
  private:
  bool _internal_has_support() const;
  public:
  void clear_support();
  ::proto::WebFeatures_Flag support() const;
  void set_support(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_support() const;
  void _internal_set_support(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
  bool has_groupuiicleanup() const;
  private:
  bool _internal_has_groupuiicleanup() const;
  public:
  void clear_groupuiicleanup();
  ::proto::WebFeatures_Flag groupuiicleanup() const;
  void set_groupuiicleanup(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_groupuiicleanup() const;
  void _internal_set_groupuiicleanup(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
  bool has_groupdogfoodinginternalonly() const;
  private:
  bool _internal_has_groupdogfoodinginternalonly() const;
  public:
  void clear_groupdogfoodinginternalonly();
  ::proto::WebFeatures_Flag groupdogfoodinginternalonly() const;
  void set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_groupdogfoodinginternalonly() const;
  void _internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag settingsSync = 42;
  bool has_settingssync() const;
  private:
  bool _internal_has_settingssync() const;
  public:
  void clear_settingssync();
  ::proto::WebFeatures_Flag settingssync() const;
  void set_settingssync(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_settingssync() const;
  void _internal_set_settingssync(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag archiveV2 = 43;
  bool has_archivev2() const;
  private:
  bool _internal_has_archivev2() const;
  public:
  void clear_archivev2();
  ::proto::WebFeatures_Flag archivev2() const;
  void set_archivev2(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_archivev2() const;
  void _internal_set_archivev2(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
  bool has_ephemeralallowgroupmembers() const;
  private:
  bool _internal_has_ephemeralallowgroupmembers() const;
  public:
  void clear_ephemeralallowgroupmembers();
  ::proto::WebFeatures_Flag ephemeralallowgroupmembers() const;
  void set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_ephemeralallowgroupmembers() const;
  void _internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
  bool has_ephemeral24hduration() const;
  private:
  bool _internal_has_ephemeral24hduration() const;
  public:
  void clear_ephemeral24hduration();
  ::proto::WebFeatures_Flag ephemeral24hduration() const;
  void set_ephemeral24hduration(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_ephemeral24hduration() const;
  void _internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
  bool has_mdforceupgrade() const;
  private:
  bool _internal_has_mdforceupgrade() const;
  public:
  void clear_mdforceupgrade();
  ::proto::WebFeatures_Flag mdforceupgrade() const;
  void set_mdforceupgrade(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_mdforceupgrade() const;
  void _internal_set_mdforceupgrade(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag disappearingMode = 47;
  bool has_disappearingmode() const;
  private:
  bool _internal_has_disappearingmode() const;
  public:
  void clear_disappearingmode();
  ::proto::WebFeatures_Flag disappearingmode() const;
  void set_disappearingmode(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_disappearingmode() const;
  void _internal_set_disappearingmode(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
  bool has_externalmdoptinavailable() const;
  private:
  bool _internal_has_externalmdoptinavailable() const;
  public:
  void clear_externalmdoptinavailable();
  ::proto::WebFeatures_Flag externalmdoptinavailable() const;
  void set_externalmdoptinavailable(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_externalmdoptinavailable() const;
  void _internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value);
  public:

  // optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
  bool has_nodeletemessagetimelimit() const;
  private:
  bool _internal_has_nodeletemessagetimelimit() const;
  public:
  void clear_nodeletemessagetimelimit();
  ::proto::WebFeatures_Flag nodeletemessagetimelimit() const;
  void set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value);
  private:
  ::proto::WebFeatures_Flag _internal_nodeletemessagetimelimit() const;
  void _internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value);
  public:

  // @@protoc_insertion_point(class_scope:proto.WebFeatures)
 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<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    int labelsdisplay_;
    int voipindividualoutgoing_;
    int groupsv3_;
    int groupsv3create_;
    int changenumberv2_;
    int querystatusv3thumbnail_;
    int livelocations_;
    int queryvname_;
    int voipindividualincoming_;
    int quickrepliesquery_;
    int payments_;
    int stickerpackquery_;
    int livelocationsfinal_;
    int labelsedit_;
    int mediaupload_;
    int mediauploadrichquickreplies_;
    int vnamev2_;
    int videoplaybackurl_;
    int statusranking_;
    int voipindividualvideo_;
    int thirdpartystickers_;
    int frequentlyforwardedsetting_;
    int groupsv4joinpermission_;
    int recentstickers_;
    int catalog_;
    int starredstickers_;
    int voipgroupcall_;
    int templatemessage_;
    int templatemessageinteractivity_;
    int ephemeralmessages_;
    int e2enotificationsync_;
    int recentstickersv2_;
    int recentstickersv3_;
    int usernotice_;
    int support_;
    int groupuiicleanup_;
    int groupdogfoodinginternalonly_;
    int settingssync_;
    int archivev2_;
    int ephemeralallowgroupmembers_;
    int ephemeral24hduration_;
    int mdforceupgrade_;
    int disappearingmode_;
    int externalmdoptinavailable_;
    int nodeletemessagetimelimit_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class WebMessageInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebMessageInfo) */ {
 public:
  inline WebMessageInfo() : WebMessageInfo(nullptr) {}
  ~WebMessageInfo() override;
  explicit PROTOBUF_CONSTEXPR WebMessageInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  WebMessageInfo(const WebMessageInfo& from);
  WebMessageInfo(WebMessageInfo&& from) noexcept
    : WebMessageInfo() {
    *this = ::std::move(from);
  }

  inline WebMessageInfo& operator=(const WebMessageInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline WebMessageInfo& operator=(WebMessageInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WebMessageInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const WebMessageInfo* internal_default_instance() {
    return reinterpret_cast<const WebMessageInfo*>(
               &_WebMessageInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    222;

  friend void swap(WebMessageInfo& a, WebMessageInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(WebMessageInfo* 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(WebMessageInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WebMessageInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WebMessageInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WebMessageInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WebMessageInfo& from) {
    WebMessageInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WebMessageInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.WebMessageInfo";
  }
  protected:
  explicit WebMessageInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef WebMessageInfo_BizPrivacyStatus BizPrivacyStatus;
  static constexpr BizPrivacyStatus E2EE =
    WebMessageInfo_BizPrivacyStatus_E2EE;
  static constexpr BizPrivacyStatus FB =
    WebMessageInfo_BizPrivacyStatus_FB;
  static constexpr BizPrivacyStatus BSP =
    WebMessageInfo_BizPrivacyStatus_BSP;
  static constexpr BizPrivacyStatus BSP_AND_FB =
    WebMessageInfo_BizPrivacyStatus_BSP_AND_FB;
  static inline bool BizPrivacyStatus_IsValid(int value) {
    return WebMessageInfo_BizPrivacyStatus_IsValid(value);
  }
  static constexpr BizPrivacyStatus BizPrivacyStatus_MIN =
    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MIN;
  static constexpr BizPrivacyStatus BizPrivacyStatus_MAX =
    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_MAX;
  static constexpr int BizPrivacyStatus_ARRAYSIZE =
    WebMessageInfo_BizPrivacyStatus_BizPrivacyStatus_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  BizPrivacyStatus_descriptor() {
    return WebMessageInfo_BizPrivacyStatus_descriptor();
  }
  template<typename T>
  static inline const std::string& BizPrivacyStatus_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BizPrivacyStatus>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BizPrivacyStatus_Name.");
    return WebMessageInfo_BizPrivacyStatus_Name(enum_t_value);
  }
  static inline bool BizPrivacyStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      BizPrivacyStatus* value) {
    return WebMessageInfo_BizPrivacyStatus_Parse(name, value);
  }

  typedef WebMessageInfo_Status Status;
  static constexpr Status ERROR =
    WebMessageInfo_Status_ERROR;
  static constexpr Status PENDING =
    WebMessageInfo_Status_PENDING;
  static constexpr Status SERVER_ACK =
    WebMessageInfo_Status_SERVER_ACK;
  static constexpr Status DELIVERY_ACK =
    WebMessageInfo_Status_DELIVERY_ACK;
  static constexpr Status READ =
    WebMessageInfo_Status_READ;
  static constexpr Status PLAYED =
    WebMessageInfo_Status_PLAYED;
  static inline bool Status_IsValid(int value) {
    return WebMessageInfo_Status_IsValid(value);
  }
  static constexpr Status Status_MIN =
    WebMessageInfo_Status_Status_MIN;
  static constexpr Status Status_MAX =
    WebMessageInfo_Status_Status_MAX;
  static constexpr int Status_ARRAYSIZE =
    WebMessageInfo_Status_Status_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Status_descriptor() {
    return WebMessageInfo_Status_descriptor();
  }
  template<typename T>
  static inline const std::string& Status_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Status>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Status_Name.");
    return WebMessageInfo_Status_Name(enum_t_value);
  }
  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Status* value) {
    return WebMessageInfo_Status_Parse(name, value);
  }

  typedef WebMessageInfo_StubType StubType;
  static constexpr StubType UNKNOWN =
    WebMessageInfo_StubType_UNKNOWN;
  static constexpr StubType REVOKE =
    WebMessageInfo_StubType_REVOKE;
  static constexpr StubType CIPHERTEXT =
    WebMessageInfo_StubType_CIPHERTEXT;
  static constexpr StubType FUTUREPROOF =
    WebMessageInfo_StubType_FUTUREPROOF;
  static constexpr StubType NON_VERIFIED_TRANSITION =
    WebMessageInfo_StubType_NON_VERIFIED_TRANSITION;
  static constexpr StubType UNVERIFIED_TRANSITION =
    WebMessageInfo_StubType_UNVERIFIED_TRANSITION;
  static constexpr StubType VERIFIED_TRANSITION =
    WebMessageInfo_StubType_VERIFIED_TRANSITION;
  static constexpr StubType VERIFIED_LOW_UNKNOWN =
    WebMessageInfo_StubType_VERIFIED_LOW_UNKNOWN;
  static constexpr StubType VERIFIED_HIGH =
    WebMessageInfo_StubType_VERIFIED_HIGH;
  static constexpr StubType VERIFIED_INITIAL_UNKNOWN =
    WebMessageInfo_StubType_VERIFIED_INITIAL_UNKNOWN;
  static constexpr StubType VERIFIED_INITIAL_LOW =
    WebMessageInfo_StubType_VERIFIED_INITIAL_LOW;
  static constexpr StubType VERIFIED_INITIAL_HIGH =
    WebMessageInfo_StubType_VERIFIED_INITIAL_HIGH;
  static constexpr StubType VERIFIED_TRANSITION_ANY_TO_NONE =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_NONE;
  static constexpr StubType VERIFIED_TRANSITION_ANY_TO_HIGH =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_ANY_TO_HIGH;
  static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_LOW =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_LOW;
  static constexpr StubType VERIFIED_TRANSITION_HIGH_TO_UNKNOWN =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_HIGH_TO_UNKNOWN;
  static constexpr StubType VERIFIED_TRANSITION_UNKNOWN_TO_LOW =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_UNKNOWN_TO_LOW;
  static constexpr StubType VERIFIED_TRANSITION_LOW_TO_UNKNOWN =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_LOW_TO_UNKNOWN;
  static constexpr StubType VERIFIED_TRANSITION_NONE_TO_LOW =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_LOW;
  static constexpr StubType VERIFIED_TRANSITION_NONE_TO_UNKNOWN =
    WebMessageInfo_StubType_VERIFIED_TRANSITION_NONE_TO_UNKNOWN;
  static constexpr StubType GROUP_CREATE =
    WebMessageInfo_StubType_GROUP_CREATE;
  static constexpr StubType GROUP_CHANGE_SUBJECT =
    WebMessageInfo_StubType_GROUP_CHANGE_SUBJECT;
  static constexpr StubType GROUP_CHANGE_ICON =
    WebMessageInfo_StubType_GROUP_CHANGE_ICON;
  static constexpr StubType GROUP_CHANGE_INVITE_LINK =
    WebMessageInfo_StubType_GROUP_CHANGE_INVITE_LINK;
  static constexpr StubType GROUP_CHANGE_DESCRIPTION =
    WebMessageInfo_StubType_GROUP_CHANGE_DESCRIPTION;
  static constexpr StubType GROUP_CHANGE_RESTRICT =
    WebMessageInfo_StubType_GROUP_CHANGE_RESTRICT;
  static constexpr StubType GROUP_CHANGE_ANNOUNCE =
    WebMessageInfo_StubType_GROUP_CHANGE_ANNOUNCE;
  static constexpr StubType GROUP_PARTICIPANT_ADD =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD;
  static constexpr StubType GROUP_PARTICIPANT_REMOVE =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_REMOVE;
  static constexpr StubType GROUP_PARTICIPANT_PROMOTE =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_PROMOTE;
  static constexpr StubType GROUP_PARTICIPANT_DEMOTE =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_DEMOTE;
  static constexpr StubType GROUP_PARTICIPANT_INVITE =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_INVITE;
  static constexpr StubType GROUP_PARTICIPANT_LEAVE =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_LEAVE;
  static constexpr StubType GROUP_PARTICIPANT_CHANGE_NUMBER =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_CHANGE_NUMBER;
  static constexpr StubType BROADCAST_CREATE =
    WebMessageInfo_StubType_BROADCAST_CREATE;
  static constexpr StubType BROADCAST_ADD =
    WebMessageInfo_StubType_BROADCAST_ADD;
  static constexpr StubType BROADCAST_REMOVE =
    WebMessageInfo_StubType_BROADCAST_REMOVE;
  static constexpr StubType GENERIC_NOTIFICATION =
    WebMessageInfo_StubType_GENERIC_NOTIFICATION;
  static constexpr StubType E2E_IDENTITY_CHANGED =
    WebMessageInfo_StubType_E2E_IDENTITY_CHANGED;
  static constexpr StubType E2E_ENCRYPTED =
    WebMessageInfo_StubType_E2E_ENCRYPTED;
  static constexpr StubType CALL_MISSED_VOICE =
    WebMessageInfo_StubType_CALL_MISSED_VOICE;
  static constexpr StubType CALL_MISSED_VIDEO =
    WebMessageInfo_StubType_CALL_MISSED_VIDEO;
  static constexpr StubType INDIVIDUAL_CHANGE_NUMBER =
    WebMessageInfo_StubType_INDIVIDUAL_CHANGE_NUMBER;
  static constexpr StubType GROUP_DELETE =
    WebMessageInfo_StubType_GROUP_DELETE;
  static constexpr StubType GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE =
    WebMessageInfo_StubType_GROUP_ANNOUNCE_MODE_MESSAGE_BOUNCE;
  static constexpr StubType CALL_MISSED_GROUP_VOICE =
    WebMessageInfo_StubType_CALL_MISSED_GROUP_VOICE;
  static constexpr StubType CALL_MISSED_GROUP_VIDEO =
    WebMessageInfo_StubType_CALL_MISSED_GROUP_VIDEO;
  static constexpr StubType PAYMENT_CIPHERTEXT =
    WebMessageInfo_StubType_PAYMENT_CIPHERTEXT;
  static constexpr StubType PAYMENT_FUTUREPROOF =
    WebMessageInfo_StubType_PAYMENT_FUTUREPROOF;
  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED =
    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_FAILED;
  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED =
    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUNDED;
  static constexpr StubType PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED =
    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_UPDATE_REFUND_FAILED;
  static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP =
    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_PENDING_SETUP;
  static constexpr StubType PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP =
    WebMessageInfo_StubType_PAYMENT_TRANSACTION_STATUS_RECEIVER_SUCCESS_AFTER_HICCUP;
  static constexpr StubType PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER =
    WebMessageInfo_StubType_PAYMENT_ACTION_ACCOUNT_SETUP_REMINDER;
  static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_REMINDER =
    WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_REMINDER;
  static constexpr StubType PAYMENT_ACTION_SEND_PAYMENT_INVITATION =
    WebMessageInfo_StubType_PAYMENT_ACTION_SEND_PAYMENT_INVITATION;
  static constexpr StubType PAYMENT_ACTION_REQUEST_DECLINED =
    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_DECLINED;
  static constexpr StubType PAYMENT_ACTION_REQUEST_EXPIRED =
    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_EXPIRED;
  static constexpr StubType PAYMENT_ACTION_REQUEST_CANCELLED =
    WebMessageInfo_StubType_PAYMENT_ACTION_REQUEST_CANCELLED;
  static constexpr StubType BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM =
    WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_TOP_TO_BOTTOM;
  static constexpr StubType BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP =
    WebMessageInfo_StubType_BIZ_VERIFIED_TRANSITION_BOTTOM_TO_TOP;
  static constexpr StubType BIZ_INTRO_TOP =
    WebMessageInfo_StubType_BIZ_INTRO_TOP;
  static constexpr StubType BIZ_INTRO_BOTTOM =
    WebMessageInfo_StubType_BIZ_INTRO_BOTTOM;
  static constexpr StubType BIZ_NAME_CHANGE =
    WebMessageInfo_StubType_BIZ_NAME_CHANGE;
  static constexpr StubType BIZ_MOVE_TO_CONSUMER_APP =
    WebMessageInfo_StubType_BIZ_MOVE_TO_CONSUMER_APP;
  static constexpr StubType BIZ_TWO_TIER_MIGRATION_TOP =
    WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_TOP;
  static constexpr StubType BIZ_TWO_TIER_MIGRATION_BOTTOM =
    WebMessageInfo_StubType_BIZ_TWO_TIER_MIGRATION_BOTTOM;
  static constexpr StubType OVERSIZED =
    WebMessageInfo_StubType_OVERSIZED;
  static constexpr StubType GROUP_CHANGE_NO_FREQUENTLY_FORWARDED =
    WebMessageInfo_StubType_GROUP_CHANGE_NO_FREQUENTLY_FORWARDED;
  static constexpr StubType GROUP_V4_ADD_INVITE_SENT =
    WebMessageInfo_StubType_GROUP_V4_ADD_INVITE_SENT;
  static constexpr StubType GROUP_PARTICIPANT_ADD_REQUEST_JOIN =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_ADD_REQUEST_JOIN;
  static constexpr StubType CHANGE_EPHEMERAL_SETTING =
    WebMessageInfo_StubType_CHANGE_EPHEMERAL_SETTING;
  static constexpr StubType E2E_DEVICE_CHANGED =
    WebMessageInfo_StubType_E2E_DEVICE_CHANGED;
  static constexpr StubType VIEWED_ONCE =
    WebMessageInfo_StubType_VIEWED_ONCE;
  static constexpr StubType E2E_ENCRYPTED_NOW =
    WebMessageInfo_StubType_E2E_ENCRYPTED_NOW;
  static constexpr StubType BLUE_MSG_BSP_FB_TO_BSP_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_BSP_PREMISE;
  static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_FB =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_FB;
  static constexpr StubType BLUE_MSG_BSP_FB_TO_SELF_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_TO_SELF_PREMISE;
  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_TO_SELF_PREMISE;
  static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_PREMISE_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_BSP_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_CONSUMER_TO_SELF_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_TO_BSP_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_BSP_PREMISE;
  static constexpr StubType BLUE_MSG_SELF_FB_TO_SELF_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_TO_SELF_PREMISE;
  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_SELF_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_SELF_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE =
    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_TO_BSP_PREMISE;
  static constexpr StubType BLUE_MSG_SELF_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_SELF_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_TO_BSP_FB =
    WebMessageInfo_StubType_BLUE_MSG_TO_BSP_FB;
  static constexpr StubType BLUE_MSG_TO_CONSUMER =
    WebMessageInfo_StubType_BLUE_MSG_TO_CONSUMER;
  static constexpr StubType BLUE_MSG_TO_SELF_FB =
    WebMessageInfo_StubType_BLUE_MSG_TO_SELF_FB;
  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_FB_VERIFIED;
  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_SELF_FB_VERIFIED;
  static constexpr StubType BLUE_MSG_UNVERIFIED_TO_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_UNVERIFIED_TO_VERIFIED;
  static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_SELF_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_VERIFIED_TO_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_VERIFIED_TO_UNVERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_UNVERIFIED_TO_SELF_FB_VERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
  static constexpr StubType BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_BSP_FB_VERIFIED_TO_SELF_FB_UNVERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_UNVERIFIED_TO_BSP_PREMISE_VERIFIED;
  static constexpr StubType BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED =
    WebMessageInfo_StubType_BLUE_MSG_SELF_FB_VERIFIED_TO_BSP_PREMISE_UNVERIFIED;
  static constexpr StubType E2E_IDENTITY_UNAVAILABLE =
    WebMessageInfo_StubType_E2E_IDENTITY_UNAVAILABLE;
  static constexpr StubType GROUP_CREATING =
    WebMessageInfo_StubType_GROUP_CREATING;
  static constexpr StubType GROUP_CREATE_FAILED =
    WebMessageInfo_StubType_GROUP_CREATE_FAILED;
  static constexpr StubType GROUP_BOUNCED =
    WebMessageInfo_StubType_GROUP_BOUNCED;
  static constexpr StubType BLOCK_CONTACT =
    WebMessageInfo_StubType_BLOCK_CONTACT;
  static constexpr StubType EPHEMERAL_SETTING_NOT_APPLIED =
    WebMessageInfo_StubType_EPHEMERAL_SETTING_NOT_APPLIED;
  static constexpr StubType SYNC_FAILED =
    WebMessageInfo_StubType_SYNC_FAILED;
  static constexpr StubType SYNCING =
    WebMessageInfo_StubType_SYNCING;
  static constexpr StubType BIZ_PRIVACY_MODE_INIT_FB =
    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_FB;
  static constexpr StubType BIZ_PRIVACY_MODE_INIT_BSP =
    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_INIT_BSP;
  static constexpr StubType BIZ_PRIVACY_MODE_TO_FB =
    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_FB;
  static constexpr StubType BIZ_PRIVACY_MODE_TO_BSP =
    WebMessageInfo_StubType_BIZ_PRIVACY_MODE_TO_BSP;
  static constexpr StubType DISAPPEARING_MODE =
    WebMessageInfo_StubType_DISAPPEARING_MODE;
  static constexpr StubType E2E_DEVICE_FETCH_FAILED =
    WebMessageInfo_StubType_E2E_DEVICE_FETCH_FAILED;
  static constexpr StubType ADMIN_REVOKE =
    WebMessageInfo_StubType_ADMIN_REVOKE;
  static constexpr StubType GROUP_INVITE_LINK_GROWTH_LOCKED =
    WebMessageInfo_StubType_GROUP_INVITE_LINK_GROWTH_LOCKED;
  static constexpr StubType COMMUNITY_LINK_PARENT_GROUP =
    WebMessageInfo_StubType_COMMUNITY_LINK_PARENT_GROUP;
  static constexpr StubType COMMUNITY_LINK_SIBLING_GROUP =
    WebMessageInfo_StubType_COMMUNITY_LINK_SIBLING_GROUP;
  static constexpr StubType COMMUNITY_LINK_SUB_GROUP =
    WebMessageInfo_StubType_COMMUNITY_LINK_SUB_GROUP;
  static constexpr StubType COMMUNITY_UNLINK_PARENT_GROUP =
    WebMessageInfo_StubType_COMMUNITY_UNLINK_PARENT_GROUP;
  static constexpr StubType COMMUNITY_UNLINK_SIBLING_GROUP =
    WebMessageInfo_StubType_COMMUNITY_UNLINK_SIBLING_GROUP;
  static constexpr StubType COMMUNITY_UNLINK_SUB_GROUP =
    WebMessageInfo_StubType_COMMUNITY_UNLINK_SUB_GROUP;
  static constexpr StubType GROUP_PARTICIPANT_ACCEPT =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_ACCEPT;
  static constexpr StubType GROUP_PARTICIPANT_LINKED_GROUP_JOIN =
    WebMessageInfo_StubType_GROUP_PARTICIPANT_LINKED_GROUP_JOIN;
  static constexpr StubType COMMUNITY_CREATE =
    WebMessageInfo_StubType_COMMUNITY_CREATE;
  static constexpr StubType EPHEMERAL_KEEP_IN_CHAT =
    WebMessageInfo_StubType_EPHEMERAL_KEEP_IN_CHAT;
  static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST =
    WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST;
  static constexpr StubType GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE =
    WebMessageInfo_StubType_GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE;
  static constexpr StubType INTEGRITY_UNLINK_PARENT_GROUP =
    WebMessageInfo_StubType_INTEGRITY_UNLINK_PARENT_GROUP;
  static constexpr StubType COMMUNITY_PARTICIPANT_PROMOTE =
    WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_PROMOTE;
  static constexpr StubType COMMUNITY_PARTICIPANT_DEMOTE =
    WebMessageInfo_StubType_COMMUNITY_PARTICIPANT_DEMOTE;
  static constexpr StubType COMMUNITY_PARENT_GROUP_DELETED =
    WebMessageInfo_StubType_COMMUNITY_PARENT_GROUP_DELETED;
  static inline bool StubType_IsValid(int value) {
    return WebMessageInfo_StubType_IsValid(value);
  }
  static constexpr StubType StubType_MIN =
    WebMessageInfo_StubType_StubType_MIN;
  static constexpr StubType StubType_MAX =
    WebMessageInfo_StubType_StubType_MAX;
  static constexpr int StubType_ARRAYSIZE =
    WebMessageInfo_StubType_StubType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  StubType_descriptor() {
    return WebMessageInfo_StubType_descriptor();
  }
  template<typename T>
  static inline const std::string& StubType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, StubType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function StubType_Name.");
    return WebMessageInfo_StubType_Name(enum_t_value);
  }
  static inline bool StubType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      StubType* value) {
    return WebMessageInfo_StubType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kMessageStubParametersFieldNumber = 26,
    kLabelsFieldNumber = 28,
    kUserReceiptFieldNumber = 40,
    kReactionsFieldNumber = 41,
    kPollUpdatesFieldNumber = 45,
    kParticipantFieldNumber = 5,
    kPushNameFieldNumber = 19,
    kMediaCiphertextSha256FieldNumber = 20,
    kVerifiedBizNameFieldNumber = 37,
    kFutureproofDataFieldNumber = 43,
    kAgentIdFieldNumber = 47,
    kMessageSecretFieldNumber = 49,
    kOriginalSelfAuthorUserJidStringFieldNumber = 51,
    kKeyFieldNumber = 1,
    kMessageFieldNumber = 2,
    kPaymentInfoFieldNumber = 29,
    kFinalLiveLocationFieldNumber = 30,
    kQuotedPaymentInfoFieldNumber = 31,
    kMediaDataFieldNumber = 38,
    kPhotoChangeFieldNumber = 39,
    kQuotedStickerDataFieldNumber = 42,
    kStatusPsaFieldNumber = 44,
    kPollAdditionalMetadataFieldNumber = 46,
    kKeepInChatFieldNumber = 50,
    kMessageTimestampFieldNumber = 3,
    kMessageC2STimestampFieldNumber = 6,
    kStatusFieldNumber = 4,
    kIgnoreFieldNumber = 16,
    kStarredFieldNumber = 17,
    kBroadcastFieldNumber = 18,
    kMulticastFieldNumber = 21,
    kMessageStubTypeFieldNumber = 24,
    kUrlTextFieldNumber = 22,
    kUrlNumberFieldNumber = 23,
    kClearMediaFieldNumber = 25,
    kEphemeralOffToOnFieldNumber = 34,
    kDurationFieldNumber = 27,
    kEphemeralDurationFieldNumber = 33,
    kEphemeralStartTimestampFieldNumber = 32,
    kBizPrivacyStatusFieldNumber = 36,
    kEphemeralOutOfSyncFieldNumber = 35,
    kStatusAlreadyViewedFieldNumber = 48,
    kRevokeMessageTimestampFieldNumber = 52,
  };
  // repeated string messageStubParameters = 26;
  int messagestubparameters_size() const;
  private:
  int _internal_messagestubparameters_size() const;
  public:
  void clear_messagestubparameters();
  const std::string& messagestubparameters(int index) const;
  std::string* mutable_messagestubparameters(int index);
  void set_messagestubparameters(int index, const std::string& value);
  void set_messagestubparameters(int index, std::string&& value);
  void set_messagestubparameters(int index, const char* value);
  void set_messagestubparameters(int index, const char* value, size_t size);
  std::string* add_messagestubparameters();
  void add_messagestubparameters(const std::string& value);
  void add_messagestubparameters(std::string&& value);
  void add_messagestubparameters(const char* value);
  void add_messagestubparameters(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& messagestubparameters() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_messagestubparameters();
  private:
  const std::string& _internal_messagestubparameters(int index) const;
  std::string* _internal_add_messagestubparameters();
  public:

  // repeated string labels = 28;
  int labels_size() const;
  private:
  int _internal_labels_size() const;
  public:
  void clear_labels();
  const std::string& labels(int index) const;
  std::string* mutable_labels(int index);
  void set_labels(int index, const std::string& value);
  void set_labels(int index, std::string&& value);
  void set_labels(int index, const char* value);
  void set_labels(int index, const char* value, size_t size);
  std::string* add_labels();
  void add_labels(const std::string& value);
  void add_labels(std::string&& value);
  void add_labels(const char* value);
  void add_labels(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& labels() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_labels();
  private:
  const std::string& _internal_labels(int index) const;
  std::string* _internal_add_labels();
  public:

  // repeated .proto.UserReceipt userReceipt = 40;
  int userreceipt_size() const;
  private:
  int _internal_userreceipt_size() const;
  public:
  void clear_userreceipt();
  ::proto::UserReceipt* mutable_userreceipt(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >*
      mutable_userreceipt();
  private:
  const ::proto::UserReceipt& _internal_userreceipt(int index) const;
  ::proto::UserReceipt* _internal_add_userreceipt();
  public:
  const ::proto::UserReceipt& userreceipt(int index) const;
  ::proto::UserReceipt* add_userreceipt();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >&
      userreceipt() const;

  // repeated .proto.Reaction reactions = 41;
  int reactions_size() const;
  private:
  int _internal_reactions_size() const;
  public:
  void clear_reactions();
  ::proto::Reaction* mutable_reactions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >*
      mutable_reactions();
  private:
  const ::proto::Reaction& _internal_reactions(int index) const;
  ::proto::Reaction* _internal_add_reactions();
  public:
  const ::proto::Reaction& reactions(int index) const;
  ::proto::Reaction* add_reactions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >&
      reactions() const;

  // repeated .proto.PollUpdate pollUpdates = 45;
  int pollupdates_size() const;
  private:
  int _internal_pollupdates_size() const;
  public:
  void clear_pollupdates();
  ::proto::PollUpdate* mutable_pollupdates(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >*
      mutable_pollupdates();
  private:
  const ::proto::PollUpdate& _internal_pollupdates(int index) const;
  ::proto::PollUpdate* _internal_add_pollupdates();
  public:
  const ::proto::PollUpdate& pollupdates(int index) const;
  ::proto::PollUpdate* add_pollupdates();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >&
      pollupdates() const;

  // optional string participant = 5;
  bool has_participant() const;
  private:
  bool _internal_has_participant() const;
  public:
  void clear_participant();
  const std::string& participant() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_participant(ArgT0&& arg0, ArgT... args);
  std::string* mutable_participant();
  PROTOBUF_NODISCARD std::string* release_participant();
  void set_allocated_participant(std::string* participant);
  private:
  const std::string& _internal_participant() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_participant(const std::string& value);
  std::string* _internal_mutable_participant();
  public:

  // optional string pushName = 19;
  bool has_pushname() const;
  private:
  bool _internal_has_pushname() const;
  public:
  void clear_pushname();
  const std::string& pushname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pushname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pushname();
  PROTOBUF_NODISCARD std::string* release_pushname();
  void set_allocated_pushname(std::string* pushname);
  private:
  const std::string& _internal_pushname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pushname(const std::string& value);
  std::string* _internal_mutable_pushname();
  public:

  // optional bytes mediaCiphertextSha256 = 20;
  bool has_mediaciphertextsha256() const;
  private:
  bool _internal_has_mediaciphertextsha256() const;
  public:
  void clear_mediaciphertextsha256();
  const std::string& mediaciphertextsha256() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args);
  std::string* mutable_mediaciphertextsha256();
  PROTOBUF_NODISCARD std::string* release_mediaciphertextsha256();
  void set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256);
  private:
  const std::string& _internal_mediaciphertextsha256() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mediaciphertextsha256(const std::string& value);
  std::string* _internal_mutable_mediaciphertextsha256();
  public:

  // optional string verifiedBizName = 37;
  bool has_verifiedbizname() const;
  private:
  bool _internal_has_verifiedbizname() const;
  public:
  void clear_verifiedbizname();
  const std::string& verifiedbizname() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_verifiedbizname(ArgT0&& arg0, ArgT... args);
  std::string* mutable_verifiedbizname();
  PROTOBUF_NODISCARD std::string* release_verifiedbizname();
  void set_allocated_verifiedbizname(std::string* verifiedbizname);
  private:
  const std::string& _internal_verifiedbizname() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_verifiedbizname(const std::string& value);
  std::string* _internal_mutable_verifiedbizname();
  public:

  // optional bytes futureproofData = 43;
  bool has_futureproofdata() const;
  private:
  bool _internal_has_futureproofdata() const;
  public:
  void clear_futureproofdata();
  const std::string& futureproofdata() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_futureproofdata(ArgT0&& arg0, ArgT... args);
  std::string* mutable_futureproofdata();
  PROTOBUF_NODISCARD std::string* release_futureproofdata();
  void set_allocated_futureproofdata(std::string* futureproofdata);
  private:
  const std::string& _internal_futureproofdata() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_futureproofdata(const std::string& value);
  std::string* _internal_mutable_futureproofdata();
  public:

  // optional string agentId = 47;
  bool has_agentid() const;
  private:
  bool _internal_has_agentid() const;
  public:
  void clear_agentid();
  const std::string& agentid() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_agentid(ArgT0&& arg0, ArgT... args);
  std::string* mutable_agentid();
  PROTOBUF_NODISCARD std::string* release_agentid();
  void set_allocated_agentid(std::string* agentid);
  private:
  const std::string& _internal_agentid() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_agentid(const std::string& value);
  std::string* _internal_mutable_agentid();
  public:

  // optional bytes messageSecret = 49;
  bool has_messagesecret() const;
  private:
  bool _internal_has_messagesecret() const;
  public:
  void clear_messagesecret();
  const std::string& messagesecret() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_messagesecret(ArgT0&& arg0, ArgT... args);
  std::string* mutable_messagesecret();
  PROTOBUF_NODISCARD std::string* release_messagesecret();
  void set_allocated_messagesecret(std::string* messagesecret);
  private:
  const std::string& _internal_messagesecret() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_messagesecret(const std::string& value);
  std::string* _internal_mutable_messagesecret();
  public:

  // optional string originalSelfAuthorUserJidString = 51;
  bool has_originalselfauthoruserjidstring() const;
  private:
  bool _internal_has_originalselfauthoruserjidstring() const;
  public:
  void clear_originalselfauthoruserjidstring();
  const std::string& originalselfauthoruserjidstring() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args);
  std::string* mutable_originalselfauthoruserjidstring();
  PROTOBUF_NODISCARD std::string* release_originalselfauthoruserjidstring();
  void set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring);
  private:
  const std::string& _internal_originalselfauthoruserjidstring() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_originalselfauthoruserjidstring(const std::string& value);
  std::string* _internal_mutable_originalselfauthoruserjidstring();
  public:

  // required .proto.MessageKey key = 1;
  bool has_key() const;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const ::proto::MessageKey& key() const;
  PROTOBUF_NODISCARD ::proto::MessageKey* release_key();
  ::proto::MessageKey* mutable_key();
  void set_allocated_key(::proto::MessageKey* key);
  private:
  const ::proto::MessageKey& _internal_key() const;
  ::proto::MessageKey* _internal_mutable_key();
  public:
  void unsafe_arena_set_allocated_key(
      ::proto::MessageKey* key);
  ::proto::MessageKey* unsafe_arena_release_key();

  // optional .proto.Message message = 2;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const ::proto::Message& message() const;
  PROTOBUF_NODISCARD ::proto::Message* release_message();
  ::proto::Message* mutable_message();
  void set_allocated_message(::proto::Message* message);
  private:
  const ::proto::Message& _internal_message() const;
  ::proto::Message* _internal_mutable_message();
  public:
  void unsafe_arena_set_allocated_message(
      ::proto::Message* message);
  ::proto::Message* unsafe_arena_release_message();

  // optional .proto.PaymentInfo paymentInfo = 29;
  bool has_paymentinfo() const;
  private:
  bool _internal_has_paymentinfo() const;
  public:
  void clear_paymentinfo();
  const ::proto::PaymentInfo& paymentinfo() const;
  PROTOBUF_NODISCARD ::proto::PaymentInfo* release_paymentinfo();
  ::proto::PaymentInfo* mutable_paymentinfo();
  void set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo);
  private:
  const ::proto::PaymentInfo& _internal_paymentinfo() const;
  ::proto::PaymentInfo* _internal_mutable_paymentinfo();
  public:
  void unsafe_arena_set_allocated_paymentinfo(
      ::proto::PaymentInfo* paymentinfo);
  ::proto::PaymentInfo* unsafe_arena_release_paymentinfo();

  // optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
  bool has_finallivelocation() const;
  private:
  bool _internal_has_finallivelocation() const;
  public:
  void clear_finallivelocation();
  const ::proto::Message_LiveLocationMessage& finallivelocation() const;
  PROTOBUF_NODISCARD ::proto::Message_LiveLocationMessage* release_finallivelocation();
  ::proto::Message_LiveLocationMessage* mutable_finallivelocation();
  void set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation);
  private:
  const ::proto::Message_LiveLocationMessage& _internal_finallivelocation() const;
  ::proto::Message_LiveLocationMessage* _internal_mutable_finallivelocation();
  public:
  void unsafe_arena_set_allocated_finallivelocation(
      ::proto::Message_LiveLocationMessage* finallivelocation);
  ::proto::Message_LiveLocationMessage* unsafe_arena_release_finallivelocation();

  // optional .proto.PaymentInfo quotedPaymentInfo = 31;
  bool has_quotedpaymentinfo() const;
  private:
  bool _internal_has_quotedpaymentinfo() const;
  public:
  void clear_quotedpaymentinfo();
  const ::proto::PaymentInfo& quotedpaymentinfo() const;
  PROTOBUF_NODISCARD ::proto::PaymentInfo* release_quotedpaymentinfo();
  ::proto::PaymentInfo* mutable_quotedpaymentinfo();
  void set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo);
  private:
  const ::proto::PaymentInfo& _internal_quotedpaymentinfo() const;
  ::proto::PaymentInfo* _internal_mutable_quotedpaymentinfo();
  public:
  void unsafe_arena_set_allocated_quotedpaymentinfo(
      ::proto::PaymentInfo* quotedpaymentinfo);
  ::proto::PaymentInfo* unsafe_arena_release_quotedpaymentinfo();

  // optional .proto.MediaData mediaData = 38;
  bool has_mediadata() const;
  private:
  bool _internal_has_mediadata() const;
  public:
  void clear_mediadata();
  const ::proto::MediaData& mediadata() const;
  PROTOBUF_NODISCARD ::proto::MediaData* release_mediadata();
  ::proto::MediaData* mutable_mediadata();
  void set_allocated_mediadata(::proto::MediaData* mediadata);
  private:
  const ::proto::MediaData& _internal_mediadata() const;
  ::proto::MediaData* _internal_mutable_mediadata();
  public:
  void unsafe_arena_set_allocated_mediadata(
      ::proto::MediaData* mediadata);
  ::proto::MediaData* unsafe_arena_release_mediadata();

  // optional .proto.PhotoChange photoChange = 39;
  bool has_photochange() const;
  private:
  bool _internal_has_photochange() const;
  public:
  void clear_photochange();
  const ::proto::PhotoChange& photochange() const;
  PROTOBUF_NODISCARD ::proto::PhotoChange* release_photochange();
  ::proto::PhotoChange* mutable_photochange();
  void set_allocated_photochange(::proto::PhotoChange* photochange);
  private:
  const ::proto::PhotoChange& _internal_photochange() const;
  ::proto::PhotoChange* _internal_mutable_photochange();
  public:
  void unsafe_arena_set_allocated_photochange(
      ::proto::PhotoChange* photochange);
  ::proto::PhotoChange* unsafe_arena_release_photochange();

  // optional .proto.MediaData quotedStickerData = 42;
  bool has_quotedstickerdata() const;
  private:
  bool _internal_has_quotedstickerdata() const;
  public:
  void clear_quotedstickerdata();
  const ::proto::MediaData& quotedstickerdata() const;
  PROTOBUF_NODISCARD ::proto::MediaData* release_quotedstickerdata();
  ::proto::MediaData* mutable_quotedstickerdata();
  void set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata);
  private:
  const ::proto::MediaData& _internal_quotedstickerdata() const;
  ::proto::MediaData* _internal_mutable_quotedstickerdata();
  public:
  void unsafe_arena_set_allocated_quotedstickerdata(
      ::proto::MediaData* quotedstickerdata);
  ::proto::MediaData* unsafe_arena_release_quotedstickerdata();

  // optional .proto.StatusPSA statusPsa = 44;
  bool has_statuspsa() const;
  private:
  bool _internal_has_statuspsa() const;
  public:
  void clear_statuspsa();
  const ::proto::StatusPSA& statuspsa() const;
  PROTOBUF_NODISCARD ::proto::StatusPSA* release_statuspsa();
  ::proto::StatusPSA* mutable_statuspsa();
  void set_allocated_statuspsa(::proto::StatusPSA* statuspsa);
  private:
  const ::proto::StatusPSA& _internal_statuspsa() const;
  ::proto::StatusPSA* _internal_mutable_statuspsa();
  public:
  void unsafe_arena_set_allocated_statuspsa(
      ::proto::StatusPSA* statuspsa);
  ::proto::StatusPSA* unsafe_arena_release_statuspsa();

  // optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
  bool has_polladditionalmetadata() const;
  private:
  bool _internal_has_polladditionalmetadata() const;
  public:
  void clear_polladditionalmetadata();
  const ::proto::PollAdditionalMetadata& polladditionalmetadata() const;
  PROTOBUF_NODISCARD ::proto::PollAdditionalMetadata* release_polladditionalmetadata();
  ::proto::PollAdditionalMetadata* mutable_polladditionalmetadata();
  void set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata);
  private:
  const ::proto::PollAdditionalMetadata& _internal_polladditionalmetadata() const;
  ::proto::PollAdditionalMetadata* _internal_mutable_polladditionalmetadata();
  public:
  void unsafe_arena_set_allocated_polladditionalmetadata(
      ::proto::PollAdditionalMetadata* polladditionalmetadata);
  ::proto::PollAdditionalMetadata* unsafe_arena_release_polladditionalmetadata();

  // optional .proto.KeepInChat keepInChat = 50;
  bool has_keepinchat() const;
  private:
  bool _internal_has_keepinchat() const;
  public:
  void clear_keepinchat();
  const ::proto::KeepInChat& keepinchat() const;
  PROTOBUF_NODISCARD ::proto::KeepInChat* release_keepinchat();
  ::proto::KeepInChat* mutable_keepinchat();
  void set_allocated_keepinchat(::proto::KeepInChat* keepinchat);
  private:
  const ::proto::KeepInChat& _internal_keepinchat() const;
  ::proto::KeepInChat* _internal_mutable_keepinchat();
  public:
  void unsafe_arena_set_allocated_keepinchat(
      ::proto::KeepInChat* keepinchat);
  ::proto::KeepInChat* unsafe_arena_release_keepinchat();

  // optional uint64 messageTimestamp = 3;
  bool has_messagetimestamp() const;
  private:
  bool _internal_has_messagetimestamp() const;
  public:
  void clear_messagetimestamp();
  uint64_t messagetimestamp() const;
  void set_messagetimestamp(uint64_t value);
  private:
  uint64_t _internal_messagetimestamp() const;
  void _internal_set_messagetimestamp(uint64_t value);
  public:

  // optional uint64 messageC2STimestamp = 6;
  bool has_messagec2stimestamp() const;
  private:
  bool _internal_has_messagec2stimestamp() const;
  public:
  void clear_messagec2stimestamp();
  uint64_t messagec2stimestamp() const;
  void set_messagec2stimestamp(uint64_t value);
  private:
  uint64_t _internal_messagec2stimestamp() const;
  void _internal_set_messagec2stimestamp(uint64_t value);
  public:

  // optional .proto.WebMessageInfo.Status status = 4;
  bool has_status() const;
  private:
  bool _internal_has_status() const;
  public:
  void clear_status();
  ::proto::WebMessageInfo_Status status() const;
  void set_status(::proto::WebMessageInfo_Status value);
  private:
  ::proto::WebMessageInfo_Status _internal_status() const;
  void _internal_set_status(::proto::WebMessageInfo_Status value);
  public:

  // optional bool ignore = 16;
  bool has_ignore() const;
  private:
  bool _internal_has_ignore() const;
  public:
  void clear_ignore();
  bool ignore() const;
  void set_ignore(bool value);
  private:
  bool _internal_ignore() const;
  void _internal_set_ignore(bool value);
  public:

  // optional bool starred = 17;
  bool has_starred() const;
  private:
  bool _internal_has_starred() const;
  public:
  void clear_starred();
  bool starred() const;
  void set_starred(bool value);
  private:
  bool _internal_starred() const;
  void _internal_set_starred(bool value);
  public:

  // optional bool broadcast = 18;
  bool has_broadcast() const;
  private:
  bool _internal_has_broadcast() const;
  public:
  void clear_broadcast();
  bool broadcast() const;
  void set_broadcast(bool value);
  private:
  bool _internal_broadcast() const;
  void _internal_set_broadcast(bool value);
  public:

  // optional bool multicast = 21;
  bool has_multicast() const;
  private:
  bool _internal_has_multicast() const;
  public:
  void clear_multicast();
  bool multicast() const;
  void set_multicast(bool value);
  private:
  bool _internal_multicast() const;
  void _internal_set_multicast(bool value);
  public:

  // optional .proto.WebMessageInfo.StubType messageStubType = 24;
  bool has_messagestubtype() const;
  private:
  bool _internal_has_messagestubtype() const;
  public:
  void clear_messagestubtype();
  ::proto::WebMessageInfo_StubType messagestubtype() const;
  void set_messagestubtype(::proto::WebMessageInfo_StubType value);
  private:
  ::proto::WebMessageInfo_StubType _internal_messagestubtype() const;
  void _internal_set_messagestubtype(::proto::WebMessageInfo_StubType value);
  public:

  // optional bool urlText = 22;
  bool has_urltext() const;
  private:
  bool _internal_has_urltext() const;
  public:
  void clear_urltext();
  bool urltext() const;
  void set_urltext(bool value);
  private:
  bool _internal_urltext() const;
  void _internal_set_urltext(bool value);
  public:

  // optional bool urlNumber = 23;
  bool has_urlnumber() const;
  private:
  bool _internal_has_urlnumber() const;
  public:
  void clear_urlnumber();
  bool urlnumber() const;
  void set_urlnumber(bool value);
  private:
  bool _internal_urlnumber() const;
  void _internal_set_urlnumber(bool value);
  public:

  // optional bool clearMedia = 25;
  bool has_clearmedia() const;
  private:
  bool _internal_has_clearmedia() const;
  public:
  void clear_clearmedia();
  bool clearmedia() const;
  void set_clearmedia(bool value);
  private:
  bool _internal_clearmedia() const;
  void _internal_set_clearmedia(bool value);
  public:

  // optional bool ephemeralOffToOn = 34;
  bool has_ephemeralofftoon() const;
  private:
  bool _internal_has_ephemeralofftoon() const;
  public:
  void clear_ephemeralofftoon();
  bool ephemeralofftoon() const;
  void set_ephemeralofftoon(bool value);
  private:
  bool _internal_ephemeralofftoon() const;
  void _internal_set_ephemeralofftoon(bool value);
  public:

  // optional uint32 duration = 27;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  uint32_t duration() const;
  void set_duration(uint32_t value);
  private:
  uint32_t _internal_duration() const;
  void _internal_set_duration(uint32_t value);
  public:

  // optional uint32 ephemeralDuration = 33;
  bool has_ephemeralduration() const;
  private:
  bool _internal_has_ephemeralduration() const;
  public:
  void clear_ephemeralduration();
  uint32_t ephemeralduration() const;
  void set_ephemeralduration(uint32_t value);
  private:
  uint32_t _internal_ephemeralduration() const;
  void _internal_set_ephemeralduration(uint32_t value);
  public:

  // optional uint64 ephemeralStartTimestamp = 32;
  bool has_ephemeralstarttimestamp() const;
  private:
  bool _internal_has_ephemeralstarttimestamp() const;
  public:
  void clear_ephemeralstarttimestamp();
  uint64_t ephemeralstarttimestamp() const;
  void set_ephemeralstarttimestamp(uint64_t value);
  private:
  uint64_t _internal_ephemeralstarttimestamp() const;
  void _internal_set_ephemeralstarttimestamp(uint64_t value);
  public:

  // optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
  bool has_bizprivacystatus() const;
  private:
  bool _internal_has_bizprivacystatus() const;
  public:
  void clear_bizprivacystatus();
  ::proto::WebMessageInfo_BizPrivacyStatus bizprivacystatus() const;
  void set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value);
  private:
  ::proto::WebMessageInfo_BizPrivacyStatus _internal_bizprivacystatus() const;
  void _internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value);
  public:

  // optional bool ephemeralOutOfSync = 35;
  bool has_ephemeraloutofsync() const;
  private:
  bool _internal_has_ephemeraloutofsync() const;
  public:
  void clear_ephemeraloutofsync();
  bool ephemeraloutofsync() const;
  void set_ephemeraloutofsync(bool value);
  private:
  bool _internal_ephemeraloutofsync() const;
  void _internal_set_ephemeraloutofsync(bool value);
  public:

  // optional bool statusAlreadyViewed = 48;
  bool has_statusalreadyviewed() const;
  private:
  bool _internal_has_statusalreadyviewed() const;
  public:
  void clear_statusalreadyviewed();
  bool statusalreadyviewed() const;
  void set_statusalreadyviewed(bool value);
  private:
  bool _internal_statusalreadyviewed() const;
  void _internal_set_statusalreadyviewed(bool value);
  public:

  // optional uint64 revokeMessageTimestamp = 52;
  bool has_revokemessagetimestamp() const;
  private:
  bool _internal_has_revokemessagetimestamp() const;
  public:
  void clear_revokemessagetimestamp();
  uint64_t revokemessagetimestamp() const;
  void set_revokemessagetimestamp(uint64_t value);
  private:
  uint64_t _internal_revokemessagetimestamp() const;
  void _internal_set_revokemessagetimestamp(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.WebMessageInfo)
 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<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> messagestubparameters_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> labels_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt > userreceipt_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction > reactions_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate > pollupdates_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr participant_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pushname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mediaciphertextsha256_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr verifiedbizname_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr futureproofdata_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr agentid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr messagesecret_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr originalselfauthoruserjidstring_;
    ::proto::MessageKey* key_;
    ::proto::Message* message_;
    ::proto::PaymentInfo* paymentinfo_;
    ::proto::Message_LiveLocationMessage* finallivelocation_;
    ::proto::PaymentInfo* quotedpaymentinfo_;
    ::proto::MediaData* mediadata_;
    ::proto::PhotoChange* photochange_;
    ::proto::MediaData* quotedstickerdata_;
    ::proto::StatusPSA* statuspsa_;
    ::proto::PollAdditionalMetadata* polladditionalmetadata_;
    ::proto::KeepInChat* keepinchat_;
    uint64_t messagetimestamp_;
    uint64_t messagec2stimestamp_;
    int status_;
    bool ignore_;
    bool starred_;
    bool broadcast_;
    bool multicast_;
    int messagestubtype_;
    bool urltext_;
    bool urlnumber_;
    bool clearmedia_;
    bool ephemeralofftoon_;
    uint32_t duration_;
    uint32_t ephemeralduration_;
    uint64_t ephemeralstarttimestamp_;
    int bizprivacystatus_;
    bool ephemeraloutofsync_;
    bool statusalreadyviewed_;
    uint64_t revokemessagetimestamp_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// -------------------------------------------------------------------

class WebNotificationsInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.WebNotificationsInfo) */ {
 public:
  inline WebNotificationsInfo() : WebNotificationsInfo(nullptr) {}
  ~WebNotificationsInfo() override;
  explicit PROTOBUF_CONSTEXPR WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  WebNotificationsInfo(const WebNotificationsInfo& from);
  WebNotificationsInfo(WebNotificationsInfo&& from) noexcept
    : WebNotificationsInfo() {
    *this = ::std::move(from);
  }

  inline WebNotificationsInfo& operator=(const WebNotificationsInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline WebNotificationsInfo& operator=(WebNotificationsInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const WebNotificationsInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const WebNotificationsInfo* internal_default_instance() {
    return reinterpret_cast<const WebNotificationsInfo*>(
               &_WebNotificationsInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    223;

  friend void swap(WebNotificationsInfo& a, WebNotificationsInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(WebNotificationsInfo* 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(WebNotificationsInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  WebNotificationsInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<WebNotificationsInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const WebNotificationsInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const WebNotificationsInfo& from) {
    WebNotificationsInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(WebNotificationsInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "proto.WebNotificationsInfo";
  }
  protected:
  explicit WebNotificationsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNotifyMessagesFieldNumber = 5,
    kTimestampFieldNumber = 2,
    kUnreadChatsFieldNumber = 3,
    kNotifyMessageCountFieldNumber = 4,
  };
  // repeated .proto.WebMessageInfo notifyMessages = 5;
  int notifymessages_size() const;
  private:
  int _internal_notifymessages_size() const;
  public:
  void clear_notifymessages();
  ::proto::WebMessageInfo* mutable_notifymessages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
      mutable_notifymessages();
  private:
  const ::proto::WebMessageInfo& _internal_notifymessages(int index) const;
  ::proto::WebMessageInfo* _internal_add_notifymessages();
  public:
  const ::proto::WebMessageInfo& notifymessages(int index) const;
  ::proto::WebMessageInfo* add_notifymessages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
      notifymessages() const;

  // 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:

  // optional uint32 unreadChats = 3;
  bool has_unreadchats() const;
  private:
  bool _internal_has_unreadchats() const;
  public:
  void clear_unreadchats();
  uint32_t unreadchats() const;
  void set_unreadchats(uint32_t value);
  private:
  uint32_t _internal_unreadchats() const;
  void _internal_set_unreadchats(uint32_t value);
  public:

  // optional uint32 notifyMessageCount = 4;
  bool has_notifymessagecount() const;
  private:
  bool _internal_has_notifymessagecount() const;
  public:
  void clear_notifymessagecount();
  uint32_t notifymessagecount() const;
  void set_notifymessagecount(uint32_t value);
  private:
  uint32_t _internal_notifymessagecount() const;
  void _internal_set_notifymessagecount(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:proto.WebNotificationsInfo)
 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< ::proto::WebMessageInfo > notifymessages_;
    uint64_t timestamp_;
    uint32_t unreadchats_;
    uint32_t notifymessagecount_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_pmsg_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// ADVDeviceIdentity

// optional uint32 rawId = 1;
inline bool ADVDeviceIdentity::_internal_has_rawid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ADVDeviceIdentity::has_rawid() const {
  return _internal_has_rawid();
}
inline void ADVDeviceIdentity::clear_rawid() {
  _impl_.rawid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ADVDeviceIdentity::_internal_rawid() const {
  return _impl_.rawid_;
}
inline uint32_t ADVDeviceIdentity::rawid() const {
  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.rawId)
  return _internal_rawid();
}
inline void ADVDeviceIdentity::_internal_set_rawid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rawid_ = value;
}
inline void ADVDeviceIdentity::set_rawid(uint32_t value) {
  _internal_set_rawid(value);
  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.rawId)
}

// optional uint64 timestamp = 2;
inline bool ADVDeviceIdentity::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ADVDeviceIdentity::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void ADVDeviceIdentity::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t ADVDeviceIdentity::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t ADVDeviceIdentity::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.timestamp)
  return _internal_timestamp();
}
inline void ADVDeviceIdentity::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void ADVDeviceIdentity::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.timestamp)
}

// optional uint32 keyIndex = 3;
inline bool ADVDeviceIdentity::_internal_has_keyindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ADVDeviceIdentity::has_keyindex() const {
  return _internal_has_keyindex();
}
inline void ADVDeviceIdentity::clear_keyindex() {
  _impl_.keyindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ADVDeviceIdentity::_internal_keyindex() const {
  return _impl_.keyindex_;
}
inline uint32_t ADVDeviceIdentity::keyindex() const {
  // @@protoc_insertion_point(field_get:proto.ADVDeviceIdentity.keyIndex)
  return _internal_keyindex();
}
inline void ADVDeviceIdentity::_internal_set_keyindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.keyindex_ = value;
}
inline void ADVDeviceIdentity::set_keyindex(uint32_t value) {
  _internal_set_keyindex(value);
  // @@protoc_insertion_point(field_set:proto.ADVDeviceIdentity.keyIndex)
}

// -------------------------------------------------------------------

// ADVKeyIndexList

// optional uint32 rawId = 1;
inline bool ADVKeyIndexList::_internal_has_rawid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ADVKeyIndexList::has_rawid() const {
  return _internal_has_rawid();
}
inline void ADVKeyIndexList::clear_rawid() {
  _impl_.rawid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ADVKeyIndexList::_internal_rawid() const {
  return _impl_.rawid_;
}
inline uint32_t ADVKeyIndexList::rawid() const {
  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.rawId)
  return _internal_rawid();
}
inline void ADVKeyIndexList::_internal_set_rawid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rawid_ = value;
}
inline void ADVKeyIndexList::set_rawid(uint32_t value) {
  _internal_set_rawid(value);
  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.rawId)
}

// optional uint64 timestamp = 2;
inline bool ADVKeyIndexList::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ADVKeyIndexList::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void ADVKeyIndexList::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t ADVKeyIndexList::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t ADVKeyIndexList::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.timestamp)
  return _internal_timestamp();
}
inline void ADVKeyIndexList::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void ADVKeyIndexList::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.timestamp)
}

// optional uint32 currentIndex = 3;
inline bool ADVKeyIndexList::_internal_has_currentindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ADVKeyIndexList::has_currentindex() const {
  return _internal_has_currentindex();
}
inline void ADVKeyIndexList::clear_currentindex() {
  _impl_.currentindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ADVKeyIndexList::_internal_currentindex() const {
  return _impl_.currentindex_;
}
inline uint32_t ADVKeyIndexList::currentindex() const {
  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.currentIndex)
  return _internal_currentindex();
}
inline void ADVKeyIndexList::_internal_set_currentindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.currentindex_ = value;
}
inline void ADVKeyIndexList::set_currentindex(uint32_t value) {
  _internal_set_currentindex(value);
  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.currentIndex)
}

// repeated uint32 validIndexes = 4 [packed = true];
inline int ADVKeyIndexList::_internal_validindexes_size() const {
  return _impl_.validindexes_.size();
}
inline int ADVKeyIndexList::validindexes_size() const {
  return _internal_validindexes_size();
}
inline void ADVKeyIndexList::clear_validindexes() {
  _impl_.validindexes_.Clear();
}
inline uint32_t ADVKeyIndexList::_internal_validindexes(int index) const {
  return _impl_.validindexes_.Get(index);
}
inline uint32_t ADVKeyIndexList::validindexes(int index) const {
  // @@protoc_insertion_point(field_get:proto.ADVKeyIndexList.validIndexes)
  return _internal_validindexes(index);
}
inline void ADVKeyIndexList::set_validindexes(int index, uint32_t value) {
  _impl_.validindexes_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.ADVKeyIndexList.validIndexes)
}
inline void ADVKeyIndexList::_internal_add_validindexes(uint32_t value) {
  _impl_.validindexes_.Add(value);
}
inline void ADVKeyIndexList::add_validindexes(uint32_t value) {
  _internal_add_validindexes(value);
  // @@protoc_insertion_point(field_add:proto.ADVKeyIndexList.validIndexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ADVKeyIndexList::_internal_validindexes() const {
  return _impl_.validindexes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
ADVKeyIndexList::validindexes() const {
  // @@protoc_insertion_point(field_list:proto.ADVKeyIndexList.validIndexes)
  return _internal_validindexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ADVKeyIndexList::_internal_mutable_validindexes() {
  return &_impl_.validindexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
ADVKeyIndexList::mutable_validindexes() {
  // @@protoc_insertion_point(field_mutable_list:proto.ADVKeyIndexList.validIndexes)
  return _internal_mutable_validindexes();
}

// -------------------------------------------------------------------

// ADVSignedDeviceIdentity

// optional bytes details = 1;
inline bool ADVSignedDeviceIdentity::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentity::has_details() const {
  return _internal_has_details();
}
inline void ADVSignedDeviceIdentity::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ADVSignedDeviceIdentity::details() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentity::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.details)
}
inline std::string* ADVSignedDeviceIdentity::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.details)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentity::_internal_details() const {
  return _impl_.details_.Get();
}
inline void ADVSignedDeviceIdentity::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::release_details() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentity::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.details)
}

// optional bytes accountSignatureKey = 2;
inline bool ADVSignedDeviceIdentity::_internal_has_accountsignaturekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentity::has_accountsignaturekey() const {
  return _internal_has_accountsignaturekey();
}
inline void ADVSignedDeviceIdentity::clear_accountsignaturekey() {
  _impl_.accountsignaturekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ADVSignedDeviceIdentity::accountsignaturekey() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignatureKey)
  return _internal_accountsignaturekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentity::set_accountsignaturekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.accountsignaturekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignatureKey)
}
inline std::string* ADVSignedDeviceIdentity::mutable_accountsignaturekey() {
  std::string* _s = _internal_mutable_accountsignaturekey();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignatureKey)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignaturekey() const {
  return _impl_.accountsignaturekey_.Get();
}
inline void ADVSignedDeviceIdentity::_internal_set_accountsignaturekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.accountsignaturekey_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignaturekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.accountsignaturekey_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::release_accountsignaturekey() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignatureKey)
  if (!_internal_has_accountsignaturekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.accountsignaturekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignaturekey_.IsDefault()) {
    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentity::set_allocated_accountsignaturekey(std::string* accountsignaturekey) {
  if (accountsignaturekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.accountsignaturekey_.SetAllocated(accountsignaturekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignaturekey_.IsDefault()) {
    _impl_.accountsignaturekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignatureKey)
}

// optional bytes accountSignature = 3;
inline bool ADVSignedDeviceIdentity::_internal_has_accountsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentity::has_accountsignature() const {
  return _internal_has_accountsignature();
}
inline void ADVSignedDeviceIdentity::clear_accountsignature() {
  _impl_.accountsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ADVSignedDeviceIdentity::accountsignature() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.accountSignature)
  return _internal_accountsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentity::set_accountsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.accountsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.accountSignature)
}
inline std::string* ADVSignedDeviceIdentity::mutable_accountsignature() {
  std::string* _s = _internal_mutable_accountsignature();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.accountSignature)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentity::_internal_accountsignature() const {
  return _impl_.accountsignature_.Get();
}
inline void ADVSignedDeviceIdentity::_internal_set_accountsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.accountsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::_internal_mutable_accountsignature() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.accountsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::release_accountsignature() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.accountSignature)
  if (!_internal_has_accountsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.accountsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignature_.IsDefault()) {
    _impl_.accountsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentity::set_allocated_accountsignature(std::string* accountsignature) {
  if (accountsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignature_.IsDefault()) {
    _impl_.accountsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.accountSignature)
}

// optional bytes deviceSignature = 4;
inline bool ADVSignedDeviceIdentity::_internal_has_devicesignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentity::has_devicesignature() const {
  return _internal_has_devicesignature();
}
inline void ADVSignedDeviceIdentity::clear_devicesignature() {
  _impl_.devicesignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ADVSignedDeviceIdentity::devicesignature() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentity.deviceSignature)
  return _internal_devicesignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentity::set_devicesignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.devicesignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentity.deviceSignature)
}
inline std::string* ADVSignedDeviceIdentity::mutable_devicesignature() {
  std::string* _s = _internal_mutable_devicesignature();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentity.deviceSignature)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentity::_internal_devicesignature() const {
  return _impl_.devicesignature_.Get();
}
inline void ADVSignedDeviceIdentity::_internal_set_devicesignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.devicesignature_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::_internal_mutable_devicesignature() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.devicesignature_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentity::release_devicesignature() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentity.deviceSignature)
  if (!_internal_has_devicesignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.devicesignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.devicesignature_.IsDefault()) {
    _impl_.devicesignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentity::set_allocated_devicesignature(std::string* devicesignature) {
  if (devicesignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.devicesignature_.SetAllocated(devicesignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.devicesignature_.IsDefault()) {
    _impl_.devicesignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentity.deviceSignature)
}

// -------------------------------------------------------------------

// ADVSignedDeviceIdentityHMAC

// optional bytes details = 1;
inline bool ADVSignedDeviceIdentityHMAC::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentityHMAC::has_details() const {
  return _internal_has_details();
}
inline void ADVSignedDeviceIdentityHMAC::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ADVSignedDeviceIdentityHMAC::details() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentityHMAC::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.details)
}
inline std::string* ADVSignedDeviceIdentityHMAC::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.details)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_details() const {
  return _impl_.details_.Get();
}
inline void ADVSignedDeviceIdentityHMAC::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentityHMAC::release_details() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentityHMAC::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.details)
}

// optional bytes hmac = 2;
inline bool ADVSignedDeviceIdentityHMAC::_internal_has_hmac() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ADVSignedDeviceIdentityHMAC::has_hmac() const {
  return _internal_has_hmac();
}
inline void ADVSignedDeviceIdentityHMAC::clear_hmac() {
  _impl_.hmac_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ADVSignedDeviceIdentityHMAC::hmac() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedDeviceIdentityHMAC.hmac)
  return _internal_hmac();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedDeviceIdentityHMAC::set_hmac(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.hmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedDeviceIdentityHMAC.hmac)
}
inline std::string* ADVSignedDeviceIdentityHMAC::mutable_hmac() {
  std::string* _s = _internal_mutable_hmac();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedDeviceIdentityHMAC.hmac)
  return _s;
}
inline const std::string& ADVSignedDeviceIdentityHMAC::_internal_hmac() const {
  return _impl_.hmac_.Get();
}
inline void ADVSignedDeviceIdentityHMAC::_internal_set_hmac(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.hmac_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentityHMAC::_internal_mutable_hmac() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.hmac_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedDeviceIdentityHMAC::release_hmac() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedDeviceIdentityHMAC.hmac)
  if (!_internal_has_hmac()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.hmac_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hmac_.IsDefault()) {
    _impl_.hmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedDeviceIdentityHMAC::set_allocated_hmac(std::string* hmac) {
  if (hmac != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.hmac_.SetAllocated(hmac, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hmac_.IsDefault()) {
    _impl_.hmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedDeviceIdentityHMAC.hmac)
}

// -------------------------------------------------------------------

// ADVSignedKeyIndexList

// optional bytes details = 1;
inline bool ADVSignedKeyIndexList::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ADVSignedKeyIndexList::has_details() const {
  return _internal_has_details();
}
inline void ADVSignedKeyIndexList::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ADVSignedKeyIndexList::details() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedKeyIndexList::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.details)
}
inline std::string* ADVSignedKeyIndexList::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.details)
  return _s;
}
inline const std::string& ADVSignedKeyIndexList::_internal_details() const {
  return _impl_.details_.Get();
}
inline void ADVSignedKeyIndexList::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedKeyIndexList::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedKeyIndexList::release_details() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedKeyIndexList::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.details)
}

// optional bytes accountSignature = 2;
inline bool ADVSignedKeyIndexList::_internal_has_accountsignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ADVSignedKeyIndexList::has_accountsignature() const {
  return _internal_has_accountsignature();
}
inline void ADVSignedKeyIndexList::clear_accountsignature() {
  _impl_.accountsignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ADVSignedKeyIndexList::accountsignature() const {
  // @@protoc_insertion_point(field_get:proto.ADVSignedKeyIndexList.accountSignature)
  return _internal_accountsignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ADVSignedKeyIndexList::set_accountsignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.accountsignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ADVSignedKeyIndexList.accountSignature)
}
inline std::string* ADVSignedKeyIndexList::mutable_accountsignature() {
  std::string* _s = _internal_mutable_accountsignature();
  // @@protoc_insertion_point(field_mutable:proto.ADVSignedKeyIndexList.accountSignature)
  return _s;
}
inline const std::string& ADVSignedKeyIndexList::_internal_accountsignature() const {
  return _impl_.accountsignature_.Get();
}
inline void ADVSignedKeyIndexList::_internal_set_accountsignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.accountsignature_.Set(value, GetArenaForAllocation());
}
inline std::string* ADVSignedKeyIndexList::_internal_mutable_accountsignature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.accountsignature_.Mutable(GetArenaForAllocation());
}
inline std::string* ADVSignedKeyIndexList::release_accountsignature() {
  // @@protoc_insertion_point(field_release:proto.ADVSignedKeyIndexList.accountSignature)
  if (!_internal_has_accountsignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.accountsignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignature_.IsDefault()) {
    _impl_.accountsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ADVSignedKeyIndexList::set_allocated_accountsignature(std::string* accountsignature) {
  if (accountsignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.accountsignature_.SetAllocated(accountsignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.accountsignature_.IsDefault()) {
    _impl_.accountsignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ADVSignedKeyIndexList.accountSignature)
}

// -------------------------------------------------------------------

// ActionLink

// optional string url = 1;
inline bool ActionLink::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ActionLink::has_url() const {
  return _internal_has_url();
}
inline void ActionLink::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ActionLink::url() const {
  // @@protoc_insertion_point(field_get:proto.ActionLink.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ActionLink::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:proto.ActionLink.url)
}
inline std::string* ActionLink::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.ActionLink.url)
  return _s;
}
inline const std::string& ActionLink::_internal_url() const {
  return _impl_.url_.Get();
}
inline void ActionLink::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* ActionLink::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* ActionLink::release_url() {
  // @@protoc_insertion_point(field_release:proto.ActionLink.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 ActionLink::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:proto.ActionLink.url)
}

// optional string buttonTitle = 2;
inline bool ActionLink::_internal_has_buttontitle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ActionLink::has_buttontitle() const {
  return _internal_has_buttontitle();
}
inline void ActionLink::clear_buttontitle() {
  _impl_.buttontitle_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ActionLink::buttontitle() const {
  // @@protoc_insertion_point(field_get:proto.ActionLink.buttonTitle)
  return _internal_buttontitle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ActionLink::set_buttontitle(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.buttontitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ActionLink.buttonTitle)
}
inline std::string* ActionLink::mutable_buttontitle() {
  std::string* _s = _internal_mutable_buttontitle();
  // @@protoc_insertion_point(field_mutable:proto.ActionLink.buttonTitle)
  return _s;
}
inline const std::string& ActionLink::_internal_buttontitle() const {
  return _impl_.buttontitle_.Get();
}
inline void ActionLink::_internal_set_buttontitle(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.buttontitle_.Set(value, GetArenaForAllocation());
}
inline std::string* ActionLink::_internal_mutable_buttontitle() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.buttontitle_.Mutable(GetArenaForAllocation());
}
inline std::string* ActionLink::release_buttontitle() {
  // @@protoc_insertion_point(field_release:proto.ActionLink.buttonTitle)
  if (!_internal_has_buttontitle()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.buttontitle_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttontitle_.IsDefault()) {
    _impl_.buttontitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ActionLink::set_allocated_buttontitle(std::string* buttontitle) {
  if (buttontitle != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.buttontitle_.SetAllocated(buttontitle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttontitle_.IsDefault()) {
    _impl_.buttontitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ActionLink.buttonTitle)
}

// -------------------------------------------------------------------

// AutoDownloadSettings

// optional bool downloadImages = 1;
inline bool AutoDownloadSettings::_internal_has_downloadimages() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool AutoDownloadSettings::has_downloadimages() const {
  return _internal_has_downloadimages();
}
inline void AutoDownloadSettings::clear_downloadimages() {
  _impl_.downloadimages_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool AutoDownloadSettings::_internal_downloadimages() const {
  return _impl_.downloadimages_;
}
inline bool AutoDownloadSettings::downloadimages() const {
  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadImages)
  return _internal_downloadimages();
}
inline void AutoDownloadSettings::_internal_set_downloadimages(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.downloadimages_ = value;
}
inline void AutoDownloadSettings::set_downloadimages(bool value) {
  _internal_set_downloadimages(value);
  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadImages)
}

// optional bool downloadAudio = 2;
inline bool AutoDownloadSettings::_internal_has_downloadaudio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool AutoDownloadSettings::has_downloadaudio() const {
  return _internal_has_downloadaudio();
}
inline void AutoDownloadSettings::clear_downloadaudio() {
  _impl_.downloadaudio_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool AutoDownloadSettings::_internal_downloadaudio() const {
  return _impl_.downloadaudio_;
}
inline bool AutoDownloadSettings::downloadaudio() const {
  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadAudio)
  return _internal_downloadaudio();
}
inline void AutoDownloadSettings::_internal_set_downloadaudio(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.downloadaudio_ = value;
}
inline void AutoDownloadSettings::set_downloadaudio(bool value) {
  _internal_set_downloadaudio(value);
  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadAudio)
}

// optional bool downloadVideo = 3;
inline bool AutoDownloadSettings::_internal_has_downloadvideo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool AutoDownloadSettings::has_downloadvideo() const {
  return _internal_has_downloadvideo();
}
inline void AutoDownloadSettings::clear_downloadvideo() {
  _impl_.downloadvideo_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool AutoDownloadSettings::_internal_downloadvideo() const {
  return _impl_.downloadvideo_;
}
inline bool AutoDownloadSettings::downloadvideo() const {
  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadVideo)
  return _internal_downloadvideo();
}
inline void AutoDownloadSettings::_internal_set_downloadvideo(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.downloadvideo_ = value;
}
inline void AutoDownloadSettings::set_downloadvideo(bool value) {
  _internal_set_downloadvideo(value);
  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadVideo)
}

// optional bool downloadDocuments = 4;
inline bool AutoDownloadSettings::_internal_has_downloaddocuments() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool AutoDownloadSettings::has_downloaddocuments() const {
  return _internal_has_downloaddocuments();
}
inline void AutoDownloadSettings::clear_downloaddocuments() {
  _impl_.downloaddocuments_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool AutoDownloadSettings::_internal_downloaddocuments() const {
  return _impl_.downloaddocuments_;
}
inline bool AutoDownloadSettings::downloaddocuments() const {
  // @@protoc_insertion_point(field_get:proto.AutoDownloadSettings.downloadDocuments)
  return _internal_downloaddocuments();
}
inline void AutoDownloadSettings::_internal_set_downloaddocuments(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.downloaddocuments_ = value;
}
inline void AutoDownloadSettings::set_downloaddocuments(bool value) {
  _internal_set_downloaddocuments(value);
  // @@protoc_insertion_point(field_set:proto.AutoDownloadSettings.downloadDocuments)
}

// -------------------------------------------------------------------

// BizAccountLinkInfo

// optional uint64 whatsappBizAcctFbid = 1;
inline bool BizAccountLinkInfo::_internal_has_whatsappbizacctfbid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BizAccountLinkInfo::has_whatsappbizacctfbid() const {
  return _internal_has_whatsappbizacctfbid();
}
inline void BizAccountLinkInfo::clear_whatsappbizacctfbid() {
  _impl_.whatsappbizacctfbid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t BizAccountLinkInfo::_internal_whatsappbizacctfbid() const {
  return _impl_.whatsappbizacctfbid_;
}
inline uint64_t BizAccountLinkInfo::whatsappbizacctfbid() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappBizAcctFbid)
  return _internal_whatsappbizacctfbid();
}
inline void BizAccountLinkInfo::_internal_set_whatsappbizacctfbid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.whatsappbizacctfbid_ = value;
}
inline void BizAccountLinkInfo::set_whatsappbizacctfbid(uint64_t value) {
  _internal_set_whatsappbizacctfbid(value);
  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappBizAcctFbid)
}

// optional string whatsappAcctNumber = 2;
inline bool BizAccountLinkInfo::_internal_has_whatsappacctnumber() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BizAccountLinkInfo::has_whatsappacctnumber() const {
  return _internal_has_whatsappacctnumber();
}
inline void BizAccountLinkInfo::clear_whatsappacctnumber() {
  _impl_.whatsappacctnumber_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BizAccountLinkInfo::whatsappacctnumber() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.whatsappAcctNumber)
  return _internal_whatsappacctnumber();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BizAccountLinkInfo::set_whatsappacctnumber(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.whatsappacctnumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.whatsappAcctNumber)
}
inline std::string* BizAccountLinkInfo::mutable_whatsappacctnumber() {
  std::string* _s = _internal_mutable_whatsappacctnumber();
  // @@protoc_insertion_point(field_mutable:proto.BizAccountLinkInfo.whatsappAcctNumber)
  return _s;
}
inline const std::string& BizAccountLinkInfo::_internal_whatsappacctnumber() const {
  return _impl_.whatsappacctnumber_.Get();
}
inline void BizAccountLinkInfo::_internal_set_whatsappacctnumber(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.whatsappacctnumber_.Set(value, GetArenaForAllocation());
}
inline std::string* BizAccountLinkInfo::_internal_mutable_whatsappacctnumber() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.whatsappacctnumber_.Mutable(GetArenaForAllocation());
}
inline std::string* BizAccountLinkInfo::release_whatsappacctnumber() {
  // @@protoc_insertion_point(field_release:proto.BizAccountLinkInfo.whatsappAcctNumber)
  if (!_internal_has_whatsappacctnumber()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.whatsappacctnumber_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.whatsappacctnumber_.IsDefault()) {
    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void BizAccountLinkInfo::set_allocated_whatsappacctnumber(std::string* whatsappacctnumber) {
  if (whatsappacctnumber != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.whatsappacctnumber_.SetAllocated(whatsappacctnumber, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.whatsappacctnumber_.IsDefault()) {
    _impl_.whatsappacctnumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountLinkInfo.whatsappAcctNumber)
}

// optional uint64 issueTime = 3;
inline bool BizAccountLinkInfo::_internal_has_issuetime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BizAccountLinkInfo::has_issuetime() const {
  return _internal_has_issuetime();
}
inline void BizAccountLinkInfo::clear_issuetime() {
  _impl_.issuetime_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t BizAccountLinkInfo::_internal_issuetime() const {
  return _impl_.issuetime_;
}
inline uint64_t BizAccountLinkInfo::issuetime() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.issueTime)
  return _internal_issuetime();
}
inline void BizAccountLinkInfo::_internal_set_issuetime(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.issuetime_ = value;
}
inline void BizAccountLinkInfo::set_issuetime(uint64_t value) {
  _internal_set_issuetime(value);
  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.issueTime)
}

// optional .proto.BizAccountLinkInfo.HostStorageType hostStorage = 4;
inline bool BizAccountLinkInfo::_internal_has_hoststorage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool BizAccountLinkInfo::has_hoststorage() const {
  return _internal_has_hoststorage();
}
inline void BizAccountLinkInfo::clear_hoststorage() {
  _impl_.hoststorage_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::_internal_hoststorage() const {
  return static_cast< ::proto::BizAccountLinkInfo_HostStorageType >(_impl_.hoststorage_);
}
inline ::proto::BizAccountLinkInfo_HostStorageType BizAccountLinkInfo::hoststorage() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.hostStorage)
  return _internal_hoststorage();
}
inline void BizAccountLinkInfo::_internal_set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) {
  assert(::proto::BizAccountLinkInfo_HostStorageType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.hoststorage_ = value;
}
inline void BizAccountLinkInfo::set_hoststorage(::proto::BizAccountLinkInfo_HostStorageType value) {
  _internal_set_hoststorage(value);
  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.hostStorage)
}

// optional .proto.BizAccountLinkInfo.AccountType accountType = 5;
inline bool BizAccountLinkInfo::_internal_has_accounttype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool BizAccountLinkInfo::has_accounttype() const {
  return _internal_has_accounttype();
}
inline void BizAccountLinkInfo::clear_accounttype() {
  _impl_.accounttype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::_internal_accounttype() const {
  return static_cast< ::proto::BizAccountLinkInfo_AccountType >(_impl_.accounttype_);
}
inline ::proto::BizAccountLinkInfo_AccountType BizAccountLinkInfo::accounttype() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountLinkInfo.accountType)
  return _internal_accounttype();
}
inline void BizAccountLinkInfo::_internal_set_accounttype(::proto::BizAccountLinkInfo_AccountType value) {
  assert(::proto::BizAccountLinkInfo_AccountType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.accounttype_ = value;
}
inline void BizAccountLinkInfo::set_accounttype(::proto::BizAccountLinkInfo_AccountType value) {
  _internal_set_accounttype(value);
  // @@protoc_insertion_point(field_set:proto.BizAccountLinkInfo.accountType)
}

// -------------------------------------------------------------------

// BizAccountPayload

// optional .proto.VerifiedNameCertificate vnameCert = 1;
inline bool BizAccountPayload::_internal_has_vnamecert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr);
  return value;
}
inline bool BizAccountPayload::has_vnamecert() const {
  return _internal_has_vnamecert();
}
inline void BizAccountPayload::clear_vnamecert() {
  if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::VerifiedNameCertificate& BizAccountPayload::_internal_vnamecert() const {
  const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::VerifiedNameCertificate&>(
      ::proto::_VerifiedNameCertificate_default_instance_);
}
inline const ::proto::VerifiedNameCertificate& BizAccountPayload::vnamecert() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountPayload.vnameCert)
  return _internal_vnamecert();
}
inline void BizAccountPayload::unsafe_arena_set_allocated_vnamecert(
    ::proto::VerifiedNameCertificate* vnamecert) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_);
  }
  _impl_.vnamecert_ = vnamecert;
  if (vnamecert) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizAccountPayload.vnameCert)
}
inline ::proto::VerifiedNameCertificate* BizAccountPayload::release_vnamecert() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
  _impl_.vnamecert_ = 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 ::proto::VerifiedNameCertificate* BizAccountPayload::unsafe_arena_release_vnamecert() {
  // @@protoc_insertion_point(field_release:proto.BizAccountPayload.vnameCert)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
  _impl_.vnamecert_ = nullptr;
  return temp;
}
inline ::proto::VerifiedNameCertificate* BizAccountPayload::_internal_mutable_vnamecert() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.vnamecert_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation());
    _impl_.vnamecert_ = p;
  }
  return _impl_.vnamecert_;
}
inline ::proto::VerifiedNameCertificate* BizAccountPayload::mutable_vnamecert() {
  ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert();
  // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.vnameCert)
  return _msg;
}
inline void BizAccountPayload::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.vnamecert_;
  }
  if (vnamecert) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert);
    if (message_arena != submessage_arena) {
      vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vnamecert, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.vnamecert_ = vnamecert;
  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.vnameCert)
}

// optional bytes bizAcctLinkInfo = 2;
inline bool BizAccountPayload::_internal_has_bizacctlinkinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool BizAccountPayload::has_bizacctlinkinfo() const {
  return _internal_has_bizacctlinkinfo();
}
inline void BizAccountPayload::clear_bizacctlinkinfo() {
  _impl_.bizacctlinkinfo_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& BizAccountPayload::bizacctlinkinfo() const {
  // @@protoc_insertion_point(field_get:proto.BizAccountPayload.bizAcctLinkInfo)
  return _internal_bizacctlinkinfo();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void BizAccountPayload::set_bizacctlinkinfo(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.bizacctlinkinfo_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.BizAccountPayload.bizAcctLinkInfo)
}
inline std::string* BizAccountPayload::mutable_bizacctlinkinfo() {
  std::string* _s = _internal_mutable_bizacctlinkinfo();
  // @@protoc_insertion_point(field_mutable:proto.BizAccountPayload.bizAcctLinkInfo)
  return _s;
}
inline const std::string& BizAccountPayload::_internal_bizacctlinkinfo() const {
  return _impl_.bizacctlinkinfo_.Get();
}
inline void BizAccountPayload::_internal_set_bizacctlinkinfo(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.bizacctlinkinfo_.Set(value, GetArenaForAllocation());
}
inline std::string* BizAccountPayload::_internal_mutable_bizacctlinkinfo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.bizacctlinkinfo_.Mutable(GetArenaForAllocation());
}
inline std::string* BizAccountPayload::release_bizacctlinkinfo() {
  // @@protoc_insertion_point(field_release:proto.BizAccountPayload.bizAcctLinkInfo)
  if (!_internal_has_bizacctlinkinfo()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.bizacctlinkinfo_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bizacctlinkinfo_.IsDefault()) {
    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void BizAccountPayload::set_allocated_bizacctlinkinfo(std::string* bizacctlinkinfo) {
  if (bizacctlinkinfo != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.bizacctlinkinfo_.SetAllocated(bizacctlinkinfo, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bizacctlinkinfo_.IsDefault()) {
    _impl_.bizacctlinkinfo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.BizAccountPayload.bizAcctLinkInfo)
}

// -------------------------------------------------------------------

// BizIdentityInfo

// optional .proto.BizIdentityInfo.VerifiedLevelValue vlevel = 1;
inline bool BizIdentityInfo::_internal_has_vlevel() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_vlevel() const {
  return _internal_has_vlevel();
}
inline void BizIdentityInfo::clear_vlevel() {
  _impl_.vlevel_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::_internal_vlevel() const {
  return static_cast< ::proto::BizIdentityInfo_VerifiedLevelValue >(_impl_.vlevel_);
}
inline ::proto::BizIdentityInfo_VerifiedLevelValue BizIdentityInfo::vlevel() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vlevel)
  return _internal_vlevel();
}
inline void BizIdentityInfo::_internal_set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) {
  assert(::proto::BizIdentityInfo_VerifiedLevelValue_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.vlevel_ = value;
}
inline void BizIdentityInfo::set_vlevel(::proto::BizIdentityInfo_VerifiedLevelValue value) {
  _internal_set_vlevel(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.vlevel)
}

// optional .proto.VerifiedNameCertificate vnameCert = 2;
inline bool BizIdentityInfo::_internal_has_vnamecert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.vnamecert_ != nullptr);
  return value;
}
inline bool BizIdentityInfo::has_vnamecert() const {
  return _internal_has_vnamecert();
}
inline void BizIdentityInfo::clear_vnamecert() {
  if (_impl_.vnamecert_ != nullptr) _impl_.vnamecert_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::_internal_vnamecert() const {
  const ::proto::VerifiedNameCertificate* p = _impl_.vnamecert_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::VerifiedNameCertificate&>(
      ::proto::_VerifiedNameCertificate_default_instance_);
}
inline const ::proto::VerifiedNameCertificate& BizIdentityInfo::vnamecert() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.vnameCert)
  return _internal_vnamecert();
}
inline void BizIdentityInfo::unsafe_arena_set_allocated_vnamecert(
    ::proto::VerifiedNameCertificate* vnamecert) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vnamecert_);
  }
  _impl_.vnamecert_ = vnamecert;
  if (vnamecert) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.BizIdentityInfo.vnameCert)
}
inline ::proto::VerifiedNameCertificate* BizIdentityInfo::release_vnamecert() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
  _impl_.vnamecert_ = 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 ::proto::VerifiedNameCertificate* BizIdentityInfo::unsafe_arena_release_vnamecert() {
  // @@protoc_insertion_point(field_release:proto.BizIdentityInfo.vnameCert)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::VerifiedNameCertificate* temp = _impl_.vnamecert_;
  _impl_.vnamecert_ = nullptr;
  return temp;
}
inline ::proto::VerifiedNameCertificate* BizIdentityInfo::_internal_mutable_vnamecert() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.vnamecert_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::VerifiedNameCertificate>(GetArenaForAllocation());
    _impl_.vnamecert_ = p;
  }
  return _impl_.vnamecert_;
}
inline ::proto::VerifiedNameCertificate* BizIdentityInfo::mutable_vnamecert() {
  ::proto::VerifiedNameCertificate* _msg = _internal_mutable_vnamecert();
  // @@protoc_insertion_point(field_mutable:proto.BizIdentityInfo.vnameCert)
  return _msg;
}
inline void BizIdentityInfo::set_allocated_vnamecert(::proto::VerifiedNameCertificate* vnamecert) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.vnamecert_;
  }
  if (vnamecert) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vnamecert);
    if (message_arena != submessage_arena) {
      vnamecert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vnamecert, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.vnamecert_ = vnamecert;
  // @@protoc_insertion_point(field_set_allocated:proto.BizIdentityInfo.vnameCert)
}

// optional bool signed = 3;
inline bool BizIdentityInfo::_internal_has_signed_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_signed_() const {
  return _internal_has_signed_();
}
inline void BizIdentityInfo::clear_signed_() {
  _impl_.signed__ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool BizIdentityInfo::_internal_signed_() const {
  return _impl_.signed__;
}
inline bool BizIdentityInfo::signed_() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.signed)
  return _internal_signed_();
}
inline void BizIdentityInfo::_internal_set_signed_(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.signed__ = value;
}
inline void BizIdentityInfo::set_signed_(bool value) {
  _internal_set_signed_(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.signed)
}

// optional bool revoked = 4;
inline bool BizIdentityInfo::_internal_has_revoked() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_revoked() const {
  return _internal_has_revoked();
}
inline void BizIdentityInfo::clear_revoked() {
  _impl_.revoked_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool BizIdentityInfo::_internal_revoked() const {
  return _impl_.revoked_;
}
inline bool BizIdentityInfo::revoked() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.revoked)
  return _internal_revoked();
}
inline void BizIdentityInfo::_internal_set_revoked(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.revoked_ = value;
}
inline void BizIdentityInfo::set_revoked(bool value) {
  _internal_set_revoked(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.revoked)
}

// optional .proto.BizIdentityInfo.HostStorageType hostStorage = 5;
inline bool BizIdentityInfo::_internal_has_hoststorage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_hoststorage() const {
  return _internal_has_hoststorage();
}
inline void BizIdentityInfo::clear_hoststorage() {
  _impl_.hoststorage_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::_internal_hoststorage() const {
  return static_cast< ::proto::BizIdentityInfo_HostStorageType >(_impl_.hoststorage_);
}
inline ::proto::BizIdentityInfo_HostStorageType BizIdentityInfo::hoststorage() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.hostStorage)
  return _internal_hoststorage();
}
inline void BizIdentityInfo::_internal_set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) {
  assert(::proto::BizIdentityInfo_HostStorageType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.hoststorage_ = value;
}
inline void BizIdentityInfo::set_hoststorage(::proto::BizIdentityInfo_HostStorageType value) {
  _internal_set_hoststorage(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.hostStorage)
}

// optional .proto.BizIdentityInfo.ActualActorsType actualActors = 6;
inline bool BizIdentityInfo::_internal_has_actualactors() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_actualactors() const {
  return _internal_has_actualactors();
}
inline void BizIdentityInfo::clear_actualactors() {
  _impl_.actualactors_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::_internal_actualactors() const {
  return static_cast< ::proto::BizIdentityInfo_ActualActorsType >(_impl_.actualactors_);
}
inline ::proto::BizIdentityInfo_ActualActorsType BizIdentityInfo::actualactors() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.actualActors)
  return _internal_actualactors();
}
inline void BizIdentityInfo::_internal_set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) {
  assert(::proto::BizIdentityInfo_ActualActorsType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.actualactors_ = value;
}
inline void BizIdentityInfo::set_actualactors(::proto::BizIdentityInfo_ActualActorsType value) {
  _internal_set_actualactors(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.actualActors)
}

// optional uint64 privacyModeTs = 7;
inline bool BizIdentityInfo::_internal_has_privacymodets() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_privacymodets() const {
  return _internal_has_privacymodets();
}
inline void BizIdentityInfo::clear_privacymodets() {
  _impl_.privacymodets_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint64_t BizIdentityInfo::_internal_privacymodets() const {
  return _impl_.privacymodets_;
}
inline uint64_t BizIdentityInfo::privacymodets() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.privacyModeTs)
  return _internal_privacymodets();
}
inline void BizIdentityInfo::_internal_set_privacymodets(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.privacymodets_ = value;
}
inline void BizIdentityInfo::set_privacymodets(uint64_t value) {
  _internal_set_privacymodets(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.privacyModeTs)
}

// optional uint64 featureControls = 8;
inline bool BizIdentityInfo::_internal_has_featurecontrols() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool BizIdentityInfo::has_featurecontrols() const {
  return _internal_has_featurecontrols();
}
inline void BizIdentityInfo::clear_featurecontrols() {
  _impl_.featurecontrols_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint64_t BizIdentityInfo::_internal_featurecontrols() const {
  return _impl_.featurecontrols_;
}
inline uint64_t BizIdentityInfo::featurecontrols() const {
  // @@protoc_insertion_point(field_get:proto.BizIdentityInfo.featureControls)
  return _internal_featurecontrols();
}
inline void BizIdentityInfo::_internal_set_featurecontrols(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.featurecontrols_ = value;
}
inline void BizIdentityInfo::set_featurecontrols(uint64_t value) {
  _internal_set_featurecontrols(value);
  // @@protoc_insertion_point(field_set:proto.BizIdentityInfo.featureControls)
}

// -------------------------------------------------------------------

// CertChain_NoiseCertificate_Details

// optional uint32 serial = 1;
inline bool CertChain_NoiseCertificate_Details::_internal_has_serial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate_Details::has_serial() const {
  return _internal_has_serial();
}
inline void CertChain_NoiseCertificate_Details::clear_serial() {
  _impl_.serial_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CertChain_NoiseCertificate_Details::_internal_serial() const {
  return _impl_.serial_;
}
inline uint32_t CertChain_NoiseCertificate_Details::serial() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.serial)
  return _internal_serial();
}
inline void CertChain_NoiseCertificate_Details::_internal_set_serial(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.serial_ = value;
}
inline void CertChain_NoiseCertificate_Details::set_serial(uint32_t value) {
  _internal_set_serial(value);
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.serial)
}

// optional uint32 issuerSerial = 2;
inline bool CertChain_NoiseCertificate_Details::_internal_has_issuerserial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate_Details::has_issuerserial() const {
  return _internal_has_issuerserial();
}
inline void CertChain_NoiseCertificate_Details::clear_issuerserial() {
  _impl_.issuerserial_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CertChain_NoiseCertificate_Details::_internal_issuerserial() const {
  return _impl_.issuerserial_;
}
inline uint32_t CertChain_NoiseCertificate_Details::issuerserial() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.issuerSerial)
  return _internal_issuerserial();
}
inline void CertChain_NoiseCertificate_Details::_internal_set_issuerserial(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.issuerserial_ = value;
}
inline void CertChain_NoiseCertificate_Details::set_issuerserial(uint32_t value) {
  _internal_set_issuerserial(value);
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.issuerSerial)
}

// optional bytes key = 3;
inline bool CertChain_NoiseCertificate_Details::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate_Details::has_key() const {
  return _internal_has_key();
}
inline void CertChain_NoiseCertificate_Details::clear_key() {
  _impl_.key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CertChain_NoiseCertificate_Details::key() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CertChain_NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.key)
}
inline std::string* CertChain_NoiseCertificate_Details::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.Details.key)
  return _s;
}
inline const std::string& CertChain_NoiseCertificate_Details::_internal_key() const {
  return _impl_.key_.Get();
}
inline void CertChain_NoiseCertificate_Details::_internal_set_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate_Details::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate_Details::release_key() {
  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.Details.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 CertChain_NoiseCertificate_Details::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.CertChain.NoiseCertificate.Details.key)
}

// optional uint64 notBefore = 4;
inline bool CertChain_NoiseCertificate_Details::_internal_has_notbefore() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate_Details::has_notbefore() const {
  return _internal_has_notbefore();
}
inline void CertChain_NoiseCertificate_Details::clear_notbefore() {
  _impl_.notbefore_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CertChain_NoiseCertificate_Details::_internal_notbefore() const {
  return _impl_.notbefore_;
}
inline uint64_t CertChain_NoiseCertificate_Details::notbefore() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notBefore)
  return _internal_notbefore();
}
inline void CertChain_NoiseCertificate_Details::_internal_set_notbefore(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.notbefore_ = value;
}
inline void CertChain_NoiseCertificate_Details::set_notbefore(uint64_t value) {
  _internal_set_notbefore(value);
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notBefore)
}

// optional uint64 notAfter = 5;
inline bool CertChain_NoiseCertificate_Details::_internal_has_notafter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate_Details::has_notafter() const {
  return _internal_has_notafter();
}
inline void CertChain_NoiseCertificate_Details::clear_notafter() {
  _impl_.notafter_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CertChain_NoiseCertificate_Details::_internal_notafter() const {
  return _impl_.notafter_;
}
inline uint64_t CertChain_NoiseCertificate_Details::notafter() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.Details.notAfter)
  return _internal_notafter();
}
inline void CertChain_NoiseCertificate_Details::_internal_set_notafter(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.notafter_ = value;
}
inline void CertChain_NoiseCertificate_Details::set_notafter(uint64_t value) {
  _internal_set_notafter(value);
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.Details.notAfter)
}

// -------------------------------------------------------------------

// CertChain_NoiseCertificate

// optional bytes details = 1;
inline bool CertChain_NoiseCertificate::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate::has_details() const {
  return _internal_has_details();
}
inline void CertChain_NoiseCertificate::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CertChain_NoiseCertificate::details() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CertChain_NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.details)
}
inline std::string* CertChain_NoiseCertificate::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.details)
  return _s;
}
inline const std::string& CertChain_NoiseCertificate::_internal_details() const {
  return _impl_.details_.Get();
}
inline void CertChain_NoiseCertificate::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate::release_details() {
  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CertChain_NoiseCertificate::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.details)
}

// optional bytes signature = 2;
inline bool CertChain_NoiseCertificate::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CertChain_NoiseCertificate::has_signature() const {
  return _internal_has_signature();
}
inline void CertChain_NoiseCertificate::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CertChain_NoiseCertificate::signature() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.NoiseCertificate.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CertChain_NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.CertChain.NoiseCertificate.signature)
}
inline std::string* CertChain_NoiseCertificate::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:proto.CertChain.NoiseCertificate.signature)
  return _s;
}
inline const std::string& CertChain_NoiseCertificate::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void CertChain_NoiseCertificate::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* CertChain_NoiseCertificate::release_signature() {
  // @@protoc_insertion_point(field_release:proto.CertChain.NoiseCertificate.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.signature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CertChain_NoiseCertificate::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.NoiseCertificate.signature)
}

// -------------------------------------------------------------------

// CertChain

// optional .proto.CertChain.NoiseCertificate leaf = 1;
inline bool CertChain::_internal_has_leaf() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.leaf_ != nullptr);
  return value;
}
inline bool CertChain::has_leaf() const {
  return _internal_has_leaf();
}
inline void CertChain::clear_leaf() {
  if (_impl_.leaf_ != nullptr) _impl_.leaf_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_leaf() const {
  const ::proto::CertChain_NoiseCertificate* p = _impl_.leaf_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::CertChain_NoiseCertificate&>(
      ::proto::_CertChain_NoiseCertificate_default_instance_);
}
inline const ::proto::CertChain_NoiseCertificate& CertChain::leaf() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.leaf)
  return _internal_leaf();
}
inline void CertChain::unsafe_arena_set_allocated_leaf(
    ::proto::CertChain_NoiseCertificate* leaf) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.leaf_);
  }
  _impl_.leaf_ = leaf;
  if (leaf) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.leaf)
}
inline ::proto::CertChain_NoiseCertificate* CertChain::release_leaf() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_;
  _impl_.leaf_ = 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 ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_leaf() {
  // @@protoc_insertion_point(field_release:proto.CertChain.leaf)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::CertChain_NoiseCertificate* temp = _impl_.leaf_;
  _impl_.leaf_ = nullptr;
  return temp;
}
inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_leaf() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.leaf_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation());
    _impl_.leaf_ = p;
  }
  return _impl_.leaf_;
}
inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_leaf() {
  ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_leaf();
  // @@protoc_insertion_point(field_mutable:proto.CertChain.leaf)
  return _msg;
}
inline void CertChain::set_allocated_leaf(::proto::CertChain_NoiseCertificate* leaf) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.leaf_;
  }
  if (leaf) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(leaf);
    if (message_arena != submessage_arena) {
      leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, leaf, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.leaf_ = leaf;
  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.leaf)
}

// optional .proto.CertChain.NoiseCertificate intermediate = 2;
inline bool CertChain::_internal_has_intermediate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.intermediate_ != nullptr);
  return value;
}
inline bool CertChain::has_intermediate() const {
  return _internal_has_intermediate();
}
inline void CertChain::clear_intermediate() {
  if (_impl_.intermediate_ != nullptr) _impl_.intermediate_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::CertChain_NoiseCertificate& CertChain::_internal_intermediate() const {
  const ::proto::CertChain_NoiseCertificate* p = _impl_.intermediate_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::CertChain_NoiseCertificate&>(
      ::proto::_CertChain_NoiseCertificate_default_instance_);
}
inline const ::proto::CertChain_NoiseCertificate& CertChain::intermediate() const {
  // @@protoc_insertion_point(field_get:proto.CertChain.intermediate)
  return _internal_intermediate();
}
inline void CertChain::unsafe_arena_set_allocated_intermediate(
    ::proto::CertChain_NoiseCertificate* intermediate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.intermediate_);
  }
  _impl_.intermediate_ = intermediate;
  if (intermediate) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.CertChain.intermediate)
}
inline ::proto::CertChain_NoiseCertificate* CertChain::release_intermediate() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_;
  _impl_.intermediate_ = 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 ::proto::CertChain_NoiseCertificate* CertChain::unsafe_arena_release_intermediate() {
  // @@protoc_insertion_point(field_release:proto.CertChain.intermediate)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::CertChain_NoiseCertificate* temp = _impl_.intermediate_;
  _impl_.intermediate_ = nullptr;
  return temp;
}
inline ::proto::CertChain_NoiseCertificate* CertChain::_internal_mutable_intermediate() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.intermediate_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::CertChain_NoiseCertificate>(GetArenaForAllocation());
    _impl_.intermediate_ = p;
  }
  return _impl_.intermediate_;
}
inline ::proto::CertChain_NoiseCertificate* CertChain::mutable_intermediate() {
  ::proto::CertChain_NoiseCertificate* _msg = _internal_mutable_intermediate();
  // @@protoc_insertion_point(field_mutable:proto.CertChain.intermediate)
  return _msg;
}
inline void CertChain::set_allocated_intermediate(::proto::CertChain_NoiseCertificate* intermediate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.intermediate_;
  }
  if (intermediate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(intermediate);
    if (message_arena != submessage_arena) {
      intermediate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, intermediate, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.intermediate_ = intermediate;
  // @@protoc_insertion_point(field_set_allocated:proto.CertChain.intermediate)
}

// -------------------------------------------------------------------

// Chain

// optional bytes senderRatchetKey = 1;
inline bool Chain::_internal_has_senderratchetkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Chain::has_senderratchetkey() const {
  return _internal_has_senderratchetkey();
}
inline void Chain::clear_senderratchetkey() {
  _impl_.senderratchetkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Chain::senderratchetkey() const {
  // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKey)
  return _internal_senderratchetkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Chain::set_senderratchetkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.senderratchetkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKey)
}
inline std::string* Chain::mutable_senderratchetkey() {
  std::string* _s = _internal_mutable_senderratchetkey();
  // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKey)
  return _s;
}
inline const std::string& Chain::_internal_senderratchetkey() const {
  return _impl_.senderratchetkey_.Get();
}
inline void Chain::_internal_set_senderratchetkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.senderratchetkey_.Set(value, GetArenaForAllocation());
}
inline std::string* Chain::_internal_mutable_senderratchetkey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.senderratchetkey_.Mutable(GetArenaForAllocation());
}
inline std::string* Chain::release_senderratchetkey() {
  // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKey)
  if (!_internal_has_senderratchetkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.senderratchetkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderratchetkey_.IsDefault()) {
    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Chain::set_allocated_senderratchetkey(std::string* senderratchetkey) {
  if (senderratchetkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.senderratchetkey_.SetAllocated(senderratchetkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderratchetkey_.IsDefault()) {
    _impl_.senderratchetkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKey)
}

// optional bytes senderRatchetKeyPrivate = 2;
inline bool Chain::_internal_has_senderratchetkeyprivate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Chain::has_senderratchetkeyprivate() const {
  return _internal_has_senderratchetkeyprivate();
}
inline void Chain::clear_senderratchetkeyprivate() {
  _impl_.senderratchetkeyprivate_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Chain::senderratchetkeyprivate() const {
  // @@protoc_insertion_point(field_get:proto.Chain.senderRatchetKeyPrivate)
  return _internal_senderratchetkeyprivate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Chain::set_senderratchetkeyprivate(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.senderratchetkeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Chain.senderRatchetKeyPrivate)
}
inline std::string* Chain::mutable_senderratchetkeyprivate() {
  std::string* _s = _internal_mutable_senderratchetkeyprivate();
  // @@protoc_insertion_point(field_mutable:proto.Chain.senderRatchetKeyPrivate)
  return _s;
}
inline const std::string& Chain::_internal_senderratchetkeyprivate() const {
  return _impl_.senderratchetkeyprivate_.Get();
}
inline void Chain::_internal_set_senderratchetkeyprivate(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.senderratchetkeyprivate_.Set(value, GetArenaForAllocation());
}
inline std::string* Chain::_internal_mutable_senderratchetkeyprivate() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.senderratchetkeyprivate_.Mutable(GetArenaForAllocation());
}
inline std::string* Chain::release_senderratchetkeyprivate() {
  // @@protoc_insertion_point(field_release:proto.Chain.senderRatchetKeyPrivate)
  if (!_internal_has_senderratchetkeyprivate()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.senderratchetkeyprivate_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderratchetkeyprivate_.IsDefault()) {
    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Chain::set_allocated_senderratchetkeyprivate(std::string* senderratchetkeyprivate) {
  if (senderratchetkeyprivate != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.senderratchetkeyprivate_.SetAllocated(senderratchetkeyprivate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderratchetkeyprivate_.IsDefault()) {
    _impl_.senderratchetkeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Chain.senderRatchetKeyPrivate)
}

// optional .proto.ChainKey chainKey = 3;
inline bool Chain::_internal_has_chainkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.chainkey_ != nullptr);
  return value;
}
inline bool Chain::has_chainkey() const {
  return _internal_has_chainkey();
}
inline void Chain::clear_chainkey() {
  if (_impl_.chainkey_ != nullptr) _impl_.chainkey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ChainKey& Chain::_internal_chainkey() const {
  const ::proto::ChainKey* p = _impl_.chainkey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ChainKey&>(
      ::proto::_ChainKey_default_instance_);
}
inline const ::proto::ChainKey& Chain::chainkey() const {
  // @@protoc_insertion_point(field_get:proto.Chain.chainKey)
  return _internal_chainkey();
}
inline void Chain::unsafe_arena_set_allocated_chainkey(
    ::proto::ChainKey* chainkey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chainkey_);
  }
  _impl_.chainkey_ = chainkey;
  if (chainkey) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Chain.chainKey)
}
inline ::proto::ChainKey* Chain::release_chainkey() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ChainKey* temp = _impl_.chainkey_;
  _impl_.chainkey_ = 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 ::proto::ChainKey* Chain::unsafe_arena_release_chainkey() {
  // @@protoc_insertion_point(field_release:proto.Chain.chainKey)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ChainKey* temp = _impl_.chainkey_;
  _impl_.chainkey_ = nullptr;
  return temp;
}
inline ::proto::ChainKey* Chain::_internal_mutable_chainkey() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.chainkey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ChainKey>(GetArenaForAllocation());
    _impl_.chainkey_ = p;
  }
  return _impl_.chainkey_;
}
inline ::proto::ChainKey* Chain::mutable_chainkey() {
  ::proto::ChainKey* _msg = _internal_mutable_chainkey();
  // @@protoc_insertion_point(field_mutable:proto.Chain.chainKey)
  return _msg;
}
inline void Chain::set_allocated_chainkey(::proto::ChainKey* chainkey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.chainkey_;
  }
  if (chainkey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chainkey);
    if (message_arena != submessage_arena) {
      chainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, chainkey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.chainkey_ = chainkey;
  // @@protoc_insertion_point(field_set_allocated:proto.Chain.chainKey)
}

// repeated .proto.MessageKey messageKeys = 4;
inline int Chain::_internal_messagekeys_size() const {
  return _impl_.messagekeys_.size();
}
inline int Chain::messagekeys_size() const {
  return _internal_messagekeys_size();
}
inline void Chain::clear_messagekeys() {
  _impl_.messagekeys_.Clear();
}
inline ::proto::MessageKey* Chain::mutable_messagekeys(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Chain.messageKeys)
  return _impl_.messagekeys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >*
Chain::mutable_messagekeys() {
  // @@protoc_insertion_point(field_mutable_list:proto.Chain.messageKeys)
  return &_impl_.messagekeys_;
}
inline const ::proto::MessageKey& Chain::_internal_messagekeys(int index) const {
  return _impl_.messagekeys_.Get(index);
}
inline const ::proto::MessageKey& Chain::messagekeys(int index) const {
  // @@protoc_insertion_point(field_get:proto.Chain.messageKeys)
  return _internal_messagekeys(index);
}
inline ::proto::MessageKey* Chain::_internal_add_messagekeys() {
  return _impl_.messagekeys_.Add();
}
inline ::proto::MessageKey* Chain::add_messagekeys() {
  ::proto::MessageKey* _add = _internal_add_messagekeys();
  // @@protoc_insertion_point(field_add:proto.Chain.messageKeys)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MessageKey >&
Chain::messagekeys() const {
  // @@protoc_insertion_point(field_list:proto.Chain.messageKeys)
  return _impl_.messagekeys_;
}

// -------------------------------------------------------------------

// ChainKey

// optional uint32 index = 1;
inline bool ChainKey::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ChainKey::has_index() const {
  return _internal_has_index();
}
inline void ChainKey::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ChainKey::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t ChainKey::index() const {
  // @@protoc_insertion_point(field_get:proto.ChainKey.index)
  return _internal_index();
}
inline void ChainKey::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.index_ = value;
}
inline void ChainKey::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:proto.ChainKey.index)
}

// optional bytes key = 2;
inline bool ChainKey::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ChainKey::has_key() const {
  return _internal_has_key();
}
inline void ChainKey::clear_key() {
  _impl_.key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ChainKey::key() const {
  // @@protoc_insertion_point(field_get:proto.ChainKey.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ChainKey::set_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ChainKey.key)
}
inline std::string* ChainKey::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.ChainKey.key)
  return _s;
}
inline const std::string& ChainKey::_internal_key() const {
  return _impl_.key_.Get();
}
inline void ChainKey::_internal_set_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* ChainKey::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* ChainKey::release_key() {
  // @@protoc_insertion_point(field_release:proto.ChainKey.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 ChainKey::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.ChainKey.key)
}

// -------------------------------------------------------------------

// ClientPayload_DNSSource

// optional .proto.ClientPayload.DNSSource.DNSResolutionMethod dnsMethod = 15;
inline bool ClientPayload_DNSSource::_internal_has_dnsmethod() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_DNSSource::has_dnsmethod() const {
  return _internal_has_dnsmethod();
}
inline void ClientPayload_DNSSource::clear_dnsmethod() {
  _impl_.dnsmethod_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::_internal_dnsmethod() const {
  return static_cast< ::proto::ClientPayload_DNSSource_DNSResolutionMethod >(_impl_.dnsmethod_);
}
inline ::proto::ClientPayload_DNSSource_DNSResolutionMethod ClientPayload_DNSSource::dnsmethod() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.dnsMethod)
  return _internal_dnsmethod();
}
inline void ClientPayload_DNSSource::_internal_set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) {
  assert(::proto::ClientPayload_DNSSource_DNSResolutionMethod_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dnsmethod_ = value;
}
inline void ClientPayload_DNSSource::set_dnsmethod(::proto::ClientPayload_DNSSource_DNSResolutionMethod value) {
  _internal_set_dnsmethod(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.dnsMethod)
}

// optional bool appCached = 16;
inline bool ClientPayload_DNSSource::_internal_has_appcached() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_DNSSource::has_appcached() const {
  return _internal_has_appcached();
}
inline void ClientPayload_DNSSource::clear_appcached() {
  _impl_.appcached_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool ClientPayload_DNSSource::_internal_appcached() const {
  return _impl_.appcached_;
}
inline bool ClientPayload_DNSSource::appcached() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DNSSource.appCached)
  return _internal_appcached();
}
inline void ClientPayload_DNSSource::_internal_set_appcached(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.appcached_ = value;
}
inline void ClientPayload_DNSSource::set_appcached(bool value) {
  _internal_set_appcached(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DNSSource.appCached)
}

// -------------------------------------------------------------------

// ClientPayload_DevicePairingRegistrationData

// optional bytes eRegid = 1;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eregid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_eregid() const {
  return _internal_has_eregid();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_eregid() {
  _impl_.eregid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::eregid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
  return _internal_eregid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_eregid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.eregid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eregid() {
  std::string* _s = _internal_mutable_eregid();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eregid() const {
  return _impl_.eregid_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eregid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.eregid_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eregid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.eregid_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_eregid() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
  if (!_internal_has_eregid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.eregid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eregid_.IsDefault()) {
    _impl_.eregid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eregid(std::string* eregid) {
  if (eregid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.eregid_.SetAllocated(eregid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eregid_.IsDefault()) {
    _impl_.eregid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eRegid)
}

// optional bytes eKeytype = 2;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_ekeytype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_ekeytype() const {
  return _internal_has_ekeytype();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_ekeytype() {
  _impl_.ekeytype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::ekeytype() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
  return _internal_ekeytype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_ekeytype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.ekeytype_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_ekeytype() {
  std::string* _s = _internal_mutable_ekeytype();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_ekeytype() const {
  return _impl_.ekeytype_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_ekeytype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ekeytype_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_ekeytype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.ekeytype_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_ekeytype() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
  if (!_internal_has_ekeytype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.ekeytype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ekeytype_.IsDefault()) {
    _impl_.ekeytype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_ekeytype(std::string* ekeytype) {
  if (ekeytype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.ekeytype_.SetAllocated(ekeytype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ekeytype_.IsDefault()) {
    _impl_.ekeytype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eKeytype)
}

// optional bytes eIdent = 3;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eident() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_eident() const {
  return _internal_has_eident();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_eident() {
  _impl_.eident_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::eident() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
  return _internal_eident();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_eident(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.eident_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eident() {
  std::string* _s = _internal_mutable_eident();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eident() const {
  return _impl_.eident_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eident(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.eident_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eident() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.eident_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_eident() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
  if (!_internal_has_eident()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.eident_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eident_.IsDefault()) {
    _impl_.eident_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eident(std::string* eident) {
  if (eident != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.eident_.SetAllocated(eident, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eident_.IsDefault()) {
    _impl_.eident_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eIdent)
}

// optional bytes eSkeyId = 4;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyid() const {
  return _internal_has_eskeyid();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyid() {
  _impl_.eskeyid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
  return _internal_eskeyid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_eskeyid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.eskeyid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyid() {
  std::string* _s = _internal_mutable_eskeyid();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyid() const {
  return _impl_.eskeyid_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.eskeyid_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyid() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.eskeyid_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyid() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
  if (!_internal_has_eskeyid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.eskeyid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeyid_.IsDefault()) {
    _impl_.eskeyid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyid(std::string* eskeyid) {
  if (eskeyid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.eskeyid_.SetAllocated(eskeyid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeyid_.IsDefault()) {
    _impl_.eskeyid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyId)
}

// optional bytes eSkeyVal = 5;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeyval() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_eskeyval() const {
  return _internal_has_eskeyval();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_eskeyval() {
  _impl_.eskeyval_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeyval() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
  return _internal_eskeyval();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_eskeyval(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.eskeyval_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeyval() {
  std::string* _s = _internal_mutable_eskeyval();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeyval() const {
  return _impl_.eskeyval_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeyval(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.eskeyval_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeyval() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.eskeyval_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeyval() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
  if (!_internal_has_eskeyval()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.eskeyval_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeyval_.IsDefault()) {
    _impl_.eskeyval_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeyval(std::string* eskeyval) {
  if (eskeyval != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.eskeyval_.SetAllocated(eskeyval, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeyval_.IsDefault()) {
    _impl_.eskeyval_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeyVal)
}

// optional bytes eSkeySig = 6;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_eskeysig() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_eskeysig() const {
  return _internal_has_eskeysig();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_eskeysig() {
  _impl_.eskeysig_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::eskeysig() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
  return _internal_eskeysig();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_eskeysig(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.eskeysig_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_eskeysig() {
  std::string* _s = _internal_mutable_eskeysig();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_eskeysig() const {
  return _impl_.eskeysig_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_eskeysig(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.eskeysig_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_eskeysig() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.eskeysig_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_eskeysig() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
  if (!_internal_has_eskeysig()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.eskeysig_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeysig_.IsDefault()) {
    _impl_.eskeysig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_eskeysig(std::string* eskeysig) {
  if (eskeysig != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.eskeysig_.SetAllocated(eskeysig, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.eskeysig_.IsDefault()) {
    _impl_.eskeysig_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.eSkeySig)
}

// optional bytes buildHash = 7;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_buildhash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_buildhash() const {
  return _internal_has_buildhash();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_buildhash() {
  _impl_.buildhash_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::buildhash() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
  return _internal_buildhash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_buildhash(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.buildhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_buildhash() {
  std::string* _s = _internal_mutable_buildhash();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_buildhash() const {
  return _impl_.buildhash_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_buildhash(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.buildhash_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_buildhash() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.buildhash_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_buildhash() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
  if (!_internal_has_buildhash()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.buildhash_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buildhash_.IsDefault()) {
    _impl_.buildhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_buildhash(std::string* buildhash) {
  if (buildhash != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.buildhash_.SetAllocated(buildhash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buildhash_.IsDefault()) {
    _impl_.buildhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.buildHash)
}

// optional bytes deviceProps = 8;
inline bool ClientPayload_DevicePairingRegistrationData::_internal_has_deviceprops() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ClientPayload_DevicePairingRegistrationData::has_deviceprops() const {
  return _internal_has_deviceprops();
}
inline void ClientPayload_DevicePairingRegistrationData::clear_deviceprops() {
  _impl_.deviceprops_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::deviceprops() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
  return _internal_deviceprops();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_DevicePairingRegistrationData::set_deviceprops(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.deviceprops_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
}
inline std::string* ClientPayload_DevicePairingRegistrationData::mutable_deviceprops() {
  std::string* _s = _internal_mutable_deviceprops();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
  return _s;
}
inline const std::string& ClientPayload_DevicePairingRegistrationData::_internal_deviceprops() const {
  return _impl_.deviceprops_.Get();
}
inline void ClientPayload_DevicePairingRegistrationData::_internal_set_deviceprops(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.deviceprops_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::_internal_mutable_deviceprops() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.deviceprops_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_DevicePairingRegistrationData::release_deviceprops() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
  if (!_internal_has_deviceprops()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.deviceprops_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deviceprops_.IsDefault()) {
    _impl_.deviceprops_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_DevicePairingRegistrationData::set_allocated_deviceprops(std::string* deviceprops) {
  if (deviceprops != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.deviceprops_.SetAllocated(deviceprops, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deviceprops_.IsDefault()) {
    _impl_.deviceprops_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.DevicePairingRegistrationData.deviceProps)
}

// -------------------------------------------------------------------

// ClientPayload_UserAgent_AppVersion

// optional uint32 primary = 1;
inline bool ClientPayload_UserAgent_AppVersion::_internal_has_primary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent_AppVersion::has_primary() const {
  return _internal_has_primary();
}
inline void ClientPayload_UserAgent_AppVersion::clear_primary() {
  _impl_.primary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_primary() const {
  return _impl_.primary_;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::primary() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.primary)
  return _internal_primary();
}
inline void ClientPayload_UserAgent_AppVersion::_internal_set_primary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.primary_ = value;
}
inline void ClientPayload_UserAgent_AppVersion::set_primary(uint32_t value) {
  _internal_set_primary(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.primary)
}

// optional uint32 secondary = 2;
inline bool ClientPayload_UserAgent_AppVersion::_internal_has_secondary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent_AppVersion::has_secondary() const {
  return _internal_has_secondary();
}
inline void ClientPayload_UserAgent_AppVersion::clear_secondary() {
  _impl_.secondary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_secondary() const {
  return _impl_.secondary_;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::secondary() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.secondary)
  return _internal_secondary();
}
inline void ClientPayload_UserAgent_AppVersion::_internal_set_secondary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.secondary_ = value;
}
inline void ClientPayload_UserAgent_AppVersion::set_secondary(uint32_t value) {
  _internal_set_secondary(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.secondary)
}

// optional uint32 tertiary = 3;
inline bool ClientPayload_UserAgent_AppVersion::_internal_has_tertiary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent_AppVersion::has_tertiary() const {
  return _internal_has_tertiary();
}
inline void ClientPayload_UserAgent_AppVersion::clear_tertiary() {
  _impl_.tertiary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_tertiary() const {
  return _impl_.tertiary_;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::tertiary() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.tertiary)
  return _internal_tertiary();
}
inline void ClientPayload_UserAgent_AppVersion::_internal_set_tertiary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.tertiary_ = value;
}
inline void ClientPayload_UserAgent_AppVersion::set_tertiary(uint32_t value) {
  _internal_set_tertiary(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.tertiary)
}

// optional uint32 quaternary = 4;
inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quaternary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent_AppVersion::has_quaternary() const {
  return _internal_has_quaternary();
}
inline void ClientPayload_UserAgent_AppVersion::clear_quaternary() {
  _impl_.quaternary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quaternary() const {
  return _impl_.quaternary_;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::quaternary() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quaternary)
  return _internal_quaternary();
}
inline void ClientPayload_UserAgent_AppVersion::_internal_set_quaternary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.quaternary_ = value;
}
inline void ClientPayload_UserAgent_AppVersion::set_quaternary(uint32_t value) {
  _internal_set_quaternary(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quaternary)
}

// optional uint32 quinary = 5;
inline bool ClientPayload_UserAgent_AppVersion::_internal_has_quinary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent_AppVersion::has_quinary() const {
  return _internal_has_quinary();
}
inline void ClientPayload_UserAgent_AppVersion::clear_quinary() {
  _impl_.quinary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::_internal_quinary() const {
  return _impl_.quinary_;
}
inline uint32_t ClientPayload_UserAgent_AppVersion::quinary() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.AppVersion.quinary)
  return _internal_quinary();
}
inline void ClientPayload_UserAgent_AppVersion::_internal_set_quinary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.quinary_ = value;
}
inline void ClientPayload_UserAgent_AppVersion::set_quinary(uint32_t value) {
  _internal_set_quinary(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.AppVersion.quinary)
}

// -------------------------------------------------------------------

// ClientPayload_UserAgent

// optional .proto.ClientPayload.UserAgent.Platform platform = 1;
inline bool ClientPayload_UserAgent::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_platform() const {
  return _internal_has_platform();
}
inline void ClientPayload_UserAgent::clear_platform() {
  _impl_.platform_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::_internal_platform() const {
  return static_cast< ::proto::ClientPayload_UserAgent_Platform >(_impl_.platform_);
}
inline ::proto::ClientPayload_UserAgent_Platform ClientPayload_UserAgent::platform() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.platform)
  return _internal_platform();
}
inline void ClientPayload_UserAgent::_internal_set_platform(::proto::ClientPayload_UserAgent_Platform value) {
  assert(::proto::ClientPayload_UserAgent_Platform_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.platform_ = value;
}
inline void ClientPayload_UserAgent::set_platform(::proto::ClientPayload_UserAgent_Platform value) {
  _internal_set_platform(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.platform)
}

// optional .proto.ClientPayload.UserAgent.AppVersion appVersion = 2;
inline bool ClientPayload_UserAgent::_internal_has_appversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.appversion_ != nullptr);
  return value;
}
inline bool ClientPayload_UserAgent::has_appversion() const {
  return _internal_has_appversion();
}
inline void ClientPayload_UserAgent::clear_appversion() {
  if (_impl_.appversion_ != nullptr) _impl_.appversion_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::_internal_appversion() const {
  const ::proto::ClientPayload_UserAgent_AppVersion* p = _impl_.appversion_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_UserAgent_AppVersion&>(
      ::proto::_ClientPayload_UserAgent_AppVersion_default_instance_);
}
inline const ::proto::ClientPayload_UserAgent_AppVersion& ClientPayload_UserAgent::appversion() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.appVersion)
  return _internal_appversion();
}
inline void ClientPayload_UserAgent::unsafe_arena_set_allocated_appversion(
    ::proto::ClientPayload_UserAgent_AppVersion* appversion) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appversion_);
  }
  _impl_.appversion_ = appversion;
  if (appversion) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.UserAgent.appVersion)
}
inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::release_appversion() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_;
  _impl_.appversion_ = 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 ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::unsafe_arena_release_appversion() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.appVersion)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::ClientPayload_UserAgent_AppVersion* temp = _impl_.appversion_;
  _impl_.appversion_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::_internal_mutable_appversion() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.appversion_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent_AppVersion>(GetArenaForAllocation());
    _impl_.appversion_ = p;
  }
  return _impl_.appversion_;
}
inline ::proto::ClientPayload_UserAgent_AppVersion* ClientPayload_UserAgent::mutable_appversion() {
  ::proto::ClientPayload_UserAgent_AppVersion* _msg = _internal_mutable_appversion();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.appVersion)
  return _msg;
}
inline void ClientPayload_UserAgent::set_allocated_appversion(::proto::ClientPayload_UserAgent_AppVersion* appversion) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.appversion_;
  }
  if (appversion) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appversion);
    if (message_arena != submessage_arena) {
      appversion = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, appversion, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.appversion_ = appversion;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.appVersion)
}

// optional string mcc = 3;
inline bool ClientPayload_UserAgent::_internal_has_mcc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_mcc() const {
  return _internal_has_mcc();
}
inline void ClientPayload_UserAgent::clear_mcc() {
  _impl_.mcc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ClientPayload_UserAgent::mcc() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mcc)
  return _internal_mcc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_mcc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mcc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mcc)
}
inline std::string* ClientPayload_UserAgent::mutable_mcc() {
  std::string* _s = _internal_mutable_mcc();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mcc)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_mcc() const {
  return _impl_.mcc_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_mcc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mcc_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_mcc() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mcc_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_mcc() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mcc)
  if (!_internal_has_mcc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mcc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mcc_.IsDefault()) {
    _impl_.mcc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_mcc(std::string* mcc) {
  if (mcc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mcc_.SetAllocated(mcc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mcc_.IsDefault()) {
    _impl_.mcc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mcc)
}

// optional string mnc = 4;
inline bool ClientPayload_UserAgent::_internal_has_mnc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_mnc() const {
  return _internal_has_mnc();
}
inline void ClientPayload_UserAgent::clear_mnc() {
  _impl_.mnc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ClientPayload_UserAgent::mnc() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.mnc)
  return _internal_mnc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_mnc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mnc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.mnc)
}
inline std::string* ClientPayload_UserAgent::mutable_mnc() {
  std::string* _s = _internal_mutable_mnc();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.mnc)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_mnc() const {
  return _impl_.mnc_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_mnc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mnc_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_mnc() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mnc_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_mnc() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.mnc)
  if (!_internal_has_mnc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mnc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mnc_.IsDefault()) {
    _impl_.mnc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_mnc(std::string* mnc) {
  if (mnc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mnc_.SetAllocated(mnc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mnc_.IsDefault()) {
    _impl_.mnc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.mnc)
}

// optional string osVersion = 5;
inline bool ClientPayload_UserAgent::_internal_has_osversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_osversion() const {
  return _internal_has_osversion();
}
inline void ClientPayload_UserAgent::clear_osversion() {
  _impl_.osversion_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ClientPayload_UserAgent::osversion() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osVersion)
  return _internal_osversion();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_osversion(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.osversion_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osVersion)
}
inline std::string* ClientPayload_UserAgent::mutable_osversion() {
  std::string* _s = _internal_mutable_osversion();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osVersion)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_osversion() const {
  return _impl_.osversion_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_osversion(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.osversion_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_osversion() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.osversion_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_osversion() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osVersion)
  if (!_internal_has_osversion()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.osversion_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osversion_.IsDefault()) {
    _impl_.osversion_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_osversion(std::string* osversion) {
  if (osversion != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.osversion_.SetAllocated(osversion, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osversion_.IsDefault()) {
    _impl_.osversion_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osVersion)
}

// optional string manufacturer = 6;
inline bool ClientPayload_UserAgent::_internal_has_manufacturer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_manufacturer() const {
  return _internal_has_manufacturer();
}
inline void ClientPayload_UserAgent::clear_manufacturer() {
  _impl_.manufacturer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ClientPayload_UserAgent::manufacturer() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.manufacturer)
  return _internal_manufacturer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_manufacturer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.manufacturer)
}
inline std::string* ClientPayload_UserAgent::mutable_manufacturer() {
  std::string* _s = _internal_mutable_manufacturer();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.manufacturer)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_manufacturer() const {
  return _impl_.manufacturer_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_manufacturer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.manufacturer_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_manufacturer() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.manufacturer_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_manufacturer() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.manufacturer)
  if (!_internal_has_manufacturer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.manufacturer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_manufacturer(std::string* manufacturer) {
  if (manufacturer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.manufacturer_.SetAllocated(manufacturer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.manufacturer_.IsDefault()) {
    _impl_.manufacturer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.manufacturer)
}

// optional string device = 7;
inline bool ClientPayload_UserAgent::_internal_has_device() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_device() const {
  return _internal_has_device();
}
inline void ClientPayload_UserAgent::clear_device() {
  _impl_.device_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ClientPayload_UserAgent::device() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.device)
  return _internal_device();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_device(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.device)
}
inline std::string* ClientPayload_UserAgent::mutable_device() {
  std::string* _s = _internal_mutable_device();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.device)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_device() const {
  return _impl_.device_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_device(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.device_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_device() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.device_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_device() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.device)
  if (!_internal_has_device()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.device_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_.IsDefault()) {
    _impl_.device_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_device(std::string* device) {
  if (device != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.device_.SetAllocated(device, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.device_.IsDefault()) {
    _impl_.device_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.device)
}

// optional string osBuildNumber = 8;
inline bool ClientPayload_UserAgent::_internal_has_osbuildnumber() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_osbuildnumber() const {
  return _internal_has_osbuildnumber();
}
inline void ClientPayload_UserAgent::clear_osbuildnumber() {
  _impl_.osbuildnumber_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& ClientPayload_UserAgent::osbuildnumber() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.osBuildNumber)
  return _internal_osbuildnumber();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_osbuildnumber(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.osbuildnumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.osBuildNumber)
}
inline std::string* ClientPayload_UserAgent::mutable_osbuildnumber() {
  std::string* _s = _internal_mutable_osbuildnumber();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.osBuildNumber)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_osbuildnumber() const {
  return _impl_.osbuildnumber_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_osbuildnumber(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.osbuildnumber_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_osbuildnumber() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.osbuildnumber_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_osbuildnumber() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.osBuildNumber)
  if (!_internal_has_osbuildnumber()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.osbuildnumber_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osbuildnumber_.IsDefault()) {
    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_osbuildnumber(std::string* osbuildnumber) {
  if (osbuildnumber != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.osbuildnumber_.SetAllocated(osbuildnumber, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.osbuildnumber_.IsDefault()) {
    _impl_.osbuildnumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.osBuildNumber)
}

// optional string phoneId = 9;
inline bool ClientPayload_UserAgent::_internal_has_phoneid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_phoneid() const {
  return _internal_has_phoneid();
}
inline void ClientPayload_UserAgent::clear_phoneid() {
  _impl_.phoneid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& ClientPayload_UserAgent::phoneid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.phoneId)
  return _internal_phoneid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_phoneid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.phoneid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.phoneId)
}
inline std::string* ClientPayload_UserAgent::mutable_phoneid() {
  std::string* _s = _internal_mutable_phoneid();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.phoneId)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_phoneid() const {
  return _impl_.phoneid_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_phoneid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.phoneid_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_phoneid() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.phoneid_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_phoneid() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.phoneId)
  if (!_internal_has_phoneid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.phoneid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phoneid_.IsDefault()) {
    _impl_.phoneid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_phoneid(std::string* phoneid) {
  if (phoneid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.phoneid_.SetAllocated(phoneid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phoneid_.IsDefault()) {
    _impl_.phoneid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.phoneId)
}

// optional .proto.ClientPayload.UserAgent.ReleaseChannel releaseChannel = 10;
inline bool ClientPayload_UserAgent::_internal_has_releasechannel() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_releasechannel() const {
  return _internal_has_releasechannel();
}
inline void ClientPayload_UserAgent::clear_releasechannel() {
  _impl_.releasechannel_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::_internal_releasechannel() const {
  return static_cast< ::proto::ClientPayload_UserAgent_ReleaseChannel >(_impl_.releasechannel_);
}
inline ::proto::ClientPayload_UserAgent_ReleaseChannel ClientPayload_UserAgent::releasechannel() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.releaseChannel)
  return _internal_releasechannel();
}
inline void ClientPayload_UserAgent::_internal_set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) {
  assert(::proto::ClientPayload_UserAgent_ReleaseChannel_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.releasechannel_ = value;
}
inline void ClientPayload_UserAgent::set_releasechannel(::proto::ClientPayload_UserAgent_ReleaseChannel value) {
  _internal_set_releasechannel(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.releaseChannel)
}

// optional string localeLanguageIso6391 = 11;
inline bool ClientPayload_UserAgent::_internal_has_localelanguageiso6391() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_localelanguageiso6391() const {
  return _internal_has_localelanguageiso6391();
}
inline void ClientPayload_UserAgent::clear_localelanguageiso6391() {
  _impl_.localelanguageiso6391_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& ClientPayload_UserAgent::localelanguageiso6391() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeLanguageIso6391)
  return _internal_localelanguageiso6391();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_localelanguageiso6391(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.localelanguageiso6391_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeLanguageIso6391)
}
inline std::string* ClientPayload_UserAgent::mutable_localelanguageiso6391() {
  std::string* _s = _internal_mutable_localelanguageiso6391();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeLanguageIso6391)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_localelanguageiso6391() const {
  return _impl_.localelanguageiso6391_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_localelanguageiso6391(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.localelanguageiso6391_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_localelanguageiso6391() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.localelanguageiso6391_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_localelanguageiso6391() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeLanguageIso6391)
  if (!_internal_has_localelanguageiso6391()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.localelanguageiso6391_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localelanguageiso6391_.IsDefault()) {
    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_localelanguageiso6391(std::string* localelanguageiso6391) {
  if (localelanguageiso6391 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.localelanguageiso6391_.SetAllocated(localelanguageiso6391, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localelanguageiso6391_.IsDefault()) {
    _impl_.localelanguageiso6391_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeLanguageIso6391)
}

// optional string localeCountryIso31661Alpha2 = 12;
inline bool ClientPayload_UserAgent::_internal_has_localecountryiso31661alpha2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_localecountryiso31661alpha2() const {
  return _internal_has_localecountryiso31661alpha2();
}
inline void ClientPayload_UserAgent::clear_localecountryiso31661alpha2() {
  _impl_.localecountryiso31661alpha2_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& ClientPayload_UserAgent::localecountryiso31661alpha2() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
  return _internal_localecountryiso31661alpha2();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_localecountryiso31661alpha2(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.localecountryiso31661alpha2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
}
inline std::string* ClientPayload_UserAgent::mutable_localecountryiso31661alpha2() {
  std::string* _s = _internal_mutable_localecountryiso31661alpha2();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_localecountryiso31661alpha2() const {
  return _impl_.localecountryiso31661alpha2_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_localecountryiso31661alpha2(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.localecountryiso31661alpha2_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_localecountryiso31661alpha2() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.localecountryiso31661alpha2_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_localecountryiso31661alpha2() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
  if (!_internal_has_localecountryiso31661alpha2()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.localecountryiso31661alpha2_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localecountryiso31661alpha2_.IsDefault()) {
    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_localecountryiso31661alpha2(std::string* localecountryiso31661alpha2) {
  if (localecountryiso31661alpha2 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.localecountryiso31661alpha2_.SetAllocated(localecountryiso31661alpha2, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localecountryiso31661alpha2_.IsDefault()) {
    _impl_.localecountryiso31661alpha2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.localeCountryIso31661Alpha2)
}

// optional string deviceBoard = 13;
inline bool ClientPayload_UserAgent::_internal_has_deviceboard() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ClientPayload_UserAgent::has_deviceboard() const {
  return _internal_has_deviceboard();
}
inline void ClientPayload_UserAgent::clear_deviceboard() {
  _impl_.deviceboard_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& ClientPayload_UserAgent::deviceboard() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.UserAgent.deviceBoard)
  return _internal_deviceboard();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_UserAgent::set_deviceboard(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.deviceboard_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.UserAgent.deviceBoard)
}
inline std::string* ClientPayload_UserAgent::mutable_deviceboard() {
  std::string* _s = _internal_mutable_deviceboard();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.UserAgent.deviceBoard)
  return _s;
}
inline const std::string& ClientPayload_UserAgent::_internal_deviceboard() const {
  return _impl_.deviceboard_.Get();
}
inline void ClientPayload_UserAgent::_internal_set_deviceboard(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.deviceboard_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::_internal_mutable_deviceboard() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.deviceboard_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_UserAgent::release_deviceboard() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.UserAgent.deviceBoard)
  if (!_internal_has_deviceboard()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.deviceboard_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deviceboard_.IsDefault()) {
    _impl_.deviceboard_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_UserAgent::set_allocated_deviceboard(std::string* deviceboard) {
  if (deviceboard != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.deviceboard_.SetAllocated(deviceboard, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deviceboard_.IsDefault()) {
    _impl_.deviceboard_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.UserAgent.deviceBoard)
}

// -------------------------------------------------------------------

// ClientPayload_WebInfo_WebdPayload

// optional bool usesParticipantInKey = 1;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_usesparticipantinkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_usesparticipantinkey() const {
  return _internal_has_usesparticipantinkey();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_usesparticipantinkey() {
  _impl_.usesparticipantinkey_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_usesparticipantinkey() const {
  return _impl_.usesparticipantinkey_;
}
inline bool ClientPayload_WebInfo_WebdPayload::usesparticipantinkey() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey)
  return _internal_usesparticipantinkey();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_usesparticipantinkey(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.usesparticipantinkey_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_usesparticipantinkey(bool value) {
  _internal_set_usesparticipantinkey(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.usesParticipantInKey)
}

// optional bool supportsStarredMessages = 2;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsstarredmessages() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportsstarredmessages() const {
  return _internal_has_supportsstarredmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportsstarredmessages() {
  _impl_.supportsstarredmessages_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsstarredmessages() const {
  return _impl_.supportsstarredmessages_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportsstarredmessages() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages)
  return _internal_supportsstarredmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsstarredmessages(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.supportsstarredmessages_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportsstarredmessages(bool value) {
  _internal_set_supportsstarredmessages(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsStarredMessages)
}

// optional bool supportsDocumentMessages = 3;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsdocumentmessages() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportsdocumentmessages() const {
  return _internal_has_supportsdocumentmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportsdocumentmessages() {
  _impl_.supportsdocumentmessages_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsdocumentmessages() const {
  return _impl_.supportsdocumentmessages_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportsdocumentmessages() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages)
  return _internal_supportsdocumentmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsdocumentmessages(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.supportsdocumentmessages_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportsdocumentmessages(bool value) {
  _internal_set_supportsdocumentmessages(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsDocumentMessages)
}

// optional bool supportsUrlMessages = 4;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsurlmessages() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportsurlmessages() const {
  return _internal_has_supportsurlmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportsurlmessages() {
  _impl_.supportsurlmessages_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsurlmessages() const {
  return _impl_.supportsurlmessages_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportsurlmessages() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages)
  return _internal_supportsurlmessages();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsurlmessages(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.supportsurlmessages_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportsurlmessages(bool value) {
  _internal_set_supportsurlmessages(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsUrlMessages)
}

// optional bool supportsMediaRetry = 5;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportsmediaretry() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportsmediaretry() const {
  return _internal_has_supportsmediaretry();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportsmediaretry() {
  _impl_.supportsmediaretry_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportsmediaretry() const {
  return _impl_.supportsmediaretry_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportsmediaretry() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry)
  return _internal_supportsmediaretry();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportsmediaretry(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.supportsmediaretry_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportsmediaretry(bool value) {
  _internal_set_supportsmediaretry(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsMediaRetry)
}

// optional bool supportsE2EImage = 6;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eimage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eimage() const {
  return _internal_has_supportse2eimage();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eimage() {
  _impl_.supportse2eimage_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eimage() const {
  return _impl_.supportse2eimage_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportse2eimage() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage)
  return _internal_supportse2eimage();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eimage(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.supportse2eimage_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eimage(bool value) {
  _internal_set_supportse2eimage(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EImage)
}

// optional bool supportsE2EVideo = 7;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2evideo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2evideo() const {
  return _internal_has_supportse2evideo();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2evideo() {
  _impl_.supportse2evideo_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2evideo() const {
  return _impl_.supportse2evideo_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportse2evideo() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo)
  return _internal_supportse2evideo();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2evideo(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.supportse2evideo_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportse2evideo(bool value) {
  _internal_set_supportse2evideo(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EVideo)
}

// optional bool supportsE2EAudio = 8;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2eaudio() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2eaudio() const {
  return _internal_has_supportse2eaudio();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2eaudio() {
  _impl_.supportse2eaudio_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2eaudio() const {
  return _impl_.supportse2eaudio_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportse2eaudio() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio)
  return _internal_supportse2eaudio();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2eaudio(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.supportse2eaudio_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportse2eaudio(bool value) {
  _internal_set_supportse2eaudio(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EAudio)
}

// optional bool supportsE2EDocument = 9;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_supportse2edocument() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_supportse2edocument() const {
  return _internal_has_supportse2edocument();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_supportse2edocument() {
  _impl_.supportse2edocument_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool ClientPayload_WebInfo_WebdPayload::_internal_supportse2edocument() const {
  return _impl_.supportse2edocument_;
}
inline bool ClientPayload_WebInfo_WebdPayload::supportse2edocument() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument)
  return _internal_supportse2edocument();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_supportse2edocument(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.supportse2edocument_ = value;
}
inline void ClientPayload_WebInfo_WebdPayload::set_supportse2edocument(bool value) {
  _internal_set_supportse2edocument(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.supportsE2EDocument)
}

// optional string documentTypes = 10;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_documenttypes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_documenttypes() const {
  return _internal_has_documenttypes();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_documenttypes() {
  _impl_.documenttypes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ClientPayload_WebInfo_WebdPayload::documenttypes() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
  return _internal_documenttypes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_WebInfo_WebdPayload::set_documenttypes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.documenttypes_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
}
inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_documenttypes() {
  std::string* _s = _internal_mutable_documenttypes();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
  return _s;
}
inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_documenttypes() const {
  return _impl_.documenttypes_.Get();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_documenttypes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.documenttypes_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_documenttypes() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.documenttypes_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo_WebdPayload::release_documenttypes() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
  if (!_internal_has_documenttypes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.documenttypes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.documenttypes_.IsDefault()) {
    _impl_.documenttypes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_WebInfo_WebdPayload::set_allocated_documenttypes(std::string* documenttypes) {
  if (documenttypes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.documenttypes_.SetAllocated(documenttypes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.documenttypes_.IsDefault()) {
    _impl_.documenttypes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.documentTypes)
}

// optional bytes features = 11;
inline bool ClientPayload_WebInfo_WebdPayload::_internal_has_features() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo_WebdPayload::has_features() const {
  return _internal_has_features();
}
inline void ClientPayload_WebInfo_WebdPayload::clear_features() {
  _impl_.features_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ClientPayload_WebInfo_WebdPayload::features() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.WebdPayload.features)
  return _internal_features();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_WebInfo_WebdPayload::set_features(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.features_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.WebdPayload.features)
}
inline std::string* ClientPayload_WebInfo_WebdPayload::mutable_features() {
  std::string* _s = _internal_mutable_features();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.WebdPayload.features)
  return _s;
}
inline const std::string& ClientPayload_WebInfo_WebdPayload::_internal_features() const {
  return _impl_.features_.Get();
}
inline void ClientPayload_WebInfo_WebdPayload::_internal_set_features(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.features_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo_WebdPayload::_internal_mutable_features() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.features_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo_WebdPayload::release_features() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.WebdPayload.features)
  if (!_internal_has_features()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.features_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.features_.IsDefault()) {
    _impl_.features_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_WebInfo_WebdPayload::set_allocated_features(std::string* features) {
  if (features != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.features_.SetAllocated(features, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.features_.IsDefault()) {
    _impl_.features_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.WebdPayload.features)
}

// -------------------------------------------------------------------

// ClientPayload_WebInfo

// optional string refToken = 1;
inline bool ClientPayload_WebInfo::_internal_has_reftoken() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo::has_reftoken() const {
  return _internal_has_reftoken();
}
inline void ClientPayload_WebInfo::clear_reftoken() {
  _impl_.reftoken_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ClientPayload_WebInfo::reftoken() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.refToken)
  return _internal_reftoken();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_WebInfo::set_reftoken(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.reftoken_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.refToken)
}
inline std::string* ClientPayload_WebInfo::mutable_reftoken() {
  std::string* _s = _internal_mutable_reftoken();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.refToken)
  return _s;
}
inline const std::string& ClientPayload_WebInfo::_internal_reftoken() const {
  return _impl_.reftoken_.Get();
}
inline void ClientPayload_WebInfo::_internal_set_reftoken(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.reftoken_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo::_internal_mutable_reftoken() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.reftoken_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo::release_reftoken() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.refToken)
  if (!_internal_has_reftoken()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.reftoken_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.reftoken_.IsDefault()) {
    _impl_.reftoken_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_WebInfo::set_allocated_reftoken(std::string* reftoken) {
  if (reftoken != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.reftoken_.SetAllocated(reftoken, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.reftoken_.IsDefault()) {
    _impl_.reftoken_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.refToken)
}

// optional string version = 2;
inline bool ClientPayload_WebInfo::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo::has_version() const {
  return _internal_has_version();
}
inline void ClientPayload_WebInfo::clear_version() {
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ClientPayload_WebInfo::version() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload_WebInfo::set_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.version)
}
inline std::string* ClientPayload_WebInfo::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.version)
  return _s;
}
inline const std::string& ClientPayload_WebInfo::_internal_version() const {
  return _impl_.version_.Get();
}
inline void ClientPayload_WebInfo::_internal_set_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload_WebInfo::release_version() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload_WebInfo::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.version)
}

// optional .proto.ClientPayload.WebInfo.WebdPayload webdPayload = 3;
inline bool ClientPayload_WebInfo::_internal_has_webdpayload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.webdpayload_ != nullptr);
  return value;
}
inline bool ClientPayload_WebInfo::has_webdpayload() const {
  return _internal_has_webdpayload();
}
inline void ClientPayload_WebInfo::clear_webdpayload() {
  if (_impl_.webdpayload_ != nullptr) _impl_.webdpayload_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::_internal_webdpayload() const {
  const ::proto::ClientPayload_WebInfo_WebdPayload* p = _impl_.webdpayload_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_WebInfo_WebdPayload&>(
      ::proto::_ClientPayload_WebInfo_WebdPayload_default_instance_);
}
inline const ::proto::ClientPayload_WebInfo_WebdPayload& ClientPayload_WebInfo::webdpayload() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webdPayload)
  return _internal_webdpayload();
}
inline void ClientPayload_WebInfo::unsafe_arena_set_allocated_webdpayload(
    ::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webdpayload_);
  }
  _impl_.webdpayload_ = webdpayload;
  if (webdpayload) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.WebInfo.webdPayload)
}
inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::release_webdpayload() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_;
  _impl_.webdpayload_ = 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 ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::unsafe_arena_release_webdpayload() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.WebInfo.webdPayload)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ClientPayload_WebInfo_WebdPayload* temp = _impl_.webdpayload_;
  _impl_.webdpayload_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::_internal_mutable_webdpayload() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.webdpayload_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo_WebdPayload>(GetArenaForAllocation());
    _impl_.webdpayload_ = p;
  }
  return _impl_.webdpayload_;
}
inline ::proto::ClientPayload_WebInfo_WebdPayload* ClientPayload_WebInfo::mutable_webdpayload() {
  ::proto::ClientPayload_WebInfo_WebdPayload* _msg = _internal_mutable_webdpayload();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.WebInfo.webdPayload)
  return _msg;
}
inline void ClientPayload_WebInfo::set_allocated_webdpayload(::proto::ClientPayload_WebInfo_WebdPayload* webdpayload) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.webdpayload_;
  }
  if (webdpayload) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webdpayload);
    if (message_arena != submessage_arena) {
      webdpayload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, webdpayload, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.webdpayload_ = webdpayload;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.WebInfo.webdPayload)
}

// optional .proto.ClientPayload.WebInfo.WebSubPlatform webSubPlatform = 4;
inline bool ClientPayload_WebInfo::_internal_has_websubplatform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload_WebInfo::has_websubplatform() const {
  return _internal_has_websubplatform();
}
inline void ClientPayload_WebInfo::clear_websubplatform() {
  _impl_.websubplatform_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::_internal_websubplatform() const {
  return static_cast< ::proto::ClientPayload_WebInfo_WebSubPlatform >(_impl_.websubplatform_);
}
inline ::proto::ClientPayload_WebInfo_WebSubPlatform ClientPayload_WebInfo::websubplatform() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.WebInfo.webSubPlatform)
  return _internal_websubplatform();
}
inline void ClientPayload_WebInfo::_internal_set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) {
  assert(::proto::ClientPayload_WebInfo_WebSubPlatform_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.websubplatform_ = value;
}
inline void ClientPayload_WebInfo::set_websubplatform(::proto::ClientPayload_WebInfo_WebSubPlatform value) {
  _internal_set_websubplatform(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.WebInfo.webSubPlatform)
}

// -------------------------------------------------------------------

// ClientPayload

// optional uint64 username = 1;
inline bool ClientPayload::_internal_has_username() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ClientPayload::has_username() const {
  return _internal_has_username();
}
inline void ClientPayload::clear_username() {
  _impl_.username_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t ClientPayload::_internal_username() const {
  return _impl_.username_;
}
inline uint64_t ClientPayload::username() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.username)
  return _internal_username();
}
inline void ClientPayload::_internal_set_username(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.username_ = value;
}
inline void ClientPayload::set_username(uint64_t value) {
  _internal_set_username(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.username)
}

// optional bool passive = 3;
inline bool ClientPayload::_internal_has_passive() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool ClientPayload::has_passive() const {
  return _internal_has_passive();
}
inline void ClientPayload::clear_passive() {
  _impl_.passive_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool ClientPayload::_internal_passive() const {
  return _impl_.passive_;
}
inline bool ClientPayload::passive() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.passive)
  return _internal_passive();
}
inline void ClientPayload::_internal_set_passive(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.passive_ = value;
}
inline void ClientPayload::set_passive(bool value) {
  _internal_set_passive(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.passive)
}

// optional .proto.ClientPayload.UserAgent userAgent = 5;
inline bool ClientPayload::_internal_has_useragent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.useragent_ != nullptr);
  return value;
}
inline bool ClientPayload::has_useragent() const {
  return _internal_has_useragent();
}
inline void ClientPayload::clear_useragent() {
  if (_impl_.useragent_ != nullptr) _impl_.useragent_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ClientPayload_UserAgent& ClientPayload::_internal_useragent() const {
  const ::proto::ClientPayload_UserAgent* p = _impl_.useragent_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_UserAgent&>(
      ::proto::_ClientPayload_UserAgent_default_instance_);
}
inline const ::proto::ClientPayload_UserAgent& ClientPayload::useragent() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.userAgent)
  return _internal_useragent();
}
inline void ClientPayload::unsafe_arena_set_allocated_useragent(
    ::proto::ClientPayload_UserAgent* useragent) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.useragent_);
  }
  _impl_.useragent_ = useragent;
  if (useragent) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.userAgent)
}
inline ::proto::ClientPayload_UserAgent* ClientPayload::release_useragent() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_;
  _impl_.useragent_ = 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 ::proto::ClientPayload_UserAgent* ClientPayload::unsafe_arena_release_useragent() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.userAgent)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ClientPayload_UserAgent* temp = _impl_.useragent_;
  _impl_.useragent_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_UserAgent* ClientPayload::_internal_mutable_useragent() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.useragent_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_UserAgent>(GetArenaForAllocation());
    _impl_.useragent_ = p;
  }
  return _impl_.useragent_;
}
inline ::proto::ClientPayload_UserAgent* ClientPayload::mutable_useragent() {
  ::proto::ClientPayload_UserAgent* _msg = _internal_mutable_useragent();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.userAgent)
  return _msg;
}
inline void ClientPayload::set_allocated_useragent(::proto::ClientPayload_UserAgent* useragent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.useragent_;
  }
  if (useragent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(useragent);
    if (message_arena != submessage_arena) {
      useragent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, useragent, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.useragent_ = useragent;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.userAgent)
}

// optional .proto.ClientPayload.WebInfo webInfo = 6;
inline bool ClientPayload::_internal_has_webinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.webinfo_ != nullptr);
  return value;
}
inline bool ClientPayload::has_webinfo() const {
  return _internal_has_webinfo();
}
inline void ClientPayload::clear_webinfo() {
  if (_impl_.webinfo_ != nullptr) _impl_.webinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::ClientPayload_WebInfo& ClientPayload::_internal_webinfo() const {
  const ::proto::ClientPayload_WebInfo* p = _impl_.webinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_WebInfo&>(
      ::proto::_ClientPayload_WebInfo_default_instance_);
}
inline const ::proto::ClientPayload_WebInfo& ClientPayload::webinfo() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.webInfo)
  return _internal_webinfo();
}
inline void ClientPayload::unsafe_arena_set_allocated_webinfo(
    ::proto::ClientPayload_WebInfo* webinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.webinfo_);
  }
  _impl_.webinfo_ = webinfo;
  if (webinfo) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.webInfo)
}
inline ::proto::ClientPayload_WebInfo* ClientPayload::release_webinfo() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_;
  _impl_.webinfo_ = 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 ::proto::ClientPayload_WebInfo* ClientPayload::unsafe_arena_release_webinfo() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.webInfo)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::ClientPayload_WebInfo* temp = _impl_.webinfo_;
  _impl_.webinfo_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_WebInfo* ClientPayload::_internal_mutable_webinfo() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.webinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_WebInfo>(GetArenaForAllocation());
    _impl_.webinfo_ = p;
  }
  return _impl_.webinfo_;
}
inline ::proto::ClientPayload_WebInfo* ClientPayload::mutable_webinfo() {
  ::proto::ClientPayload_WebInfo* _msg = _internal_mutable_webinfo();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.webInfo)
  return _msg;
}
inline void ClientPayload::set_allocated_webinfo(::proto::ClientPayload_WebInfo* webinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.webinfo_;
  }
  if (webinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(webinfo);
    if (message_arena != submessage_arena) {
      webinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, webinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.webinfo_ = webinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.webInfo)
}

// optional string pushName = 7;
inline bool ClientPayload::_internal_has_pushname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ClientPayload::has_pushname() const {
  return _internal_has_pushname();
}
inline void ClientPayload::clear_pushname() {
  _impl_.pushname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ClientPayload::pushname() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.pushName)
  return _internal_pushname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload::set_pushname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.pushName)
}
inline std::string* ClientPayload::mutable_pushname() {
  std::string* _s = _internal_mutable_pushname();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.pushName)
  return _s;
}
inline const std::string& ClientPayload::_internal_pushname() const {
  return _impl_.pushname_.Get();
}
inline void ClientPayload::_internal_set_pushname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pushname_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload::_internal_mutable_pushname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.pushname_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload::release_pushname() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.pushName)
  if (!_internal_has_pushname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.pushname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload::set_allocated_pushname(std::string* pushname) {
  if (pushname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.pushName)
}

// optional sfixed32 sessionId = 9;
inline bool ClientPayload::_internal_has_sessionid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ClientPayload::has_sessionid() const {
  return _internal_has_sessionid();
}
inline void ClientPayload::clear_sessionid() {
  _impl_.sessionid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline int32_t ClientPayload::_internal_sessionid() const {
  return _impl_.sessionid_;
}
inline int32_t ClientPayload::sessionid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.sessionId)
  return _internal_sessionid();
}
inline void ClientPayload::_internal_set_sessionid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.sessionid_ = value;
}
inline void ClientPayload::set_sessionid(int32_t value) {
  _internal_set_sessionid(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.sessionId)
}

// optional bool shortConnect = 10;
inline bool ClientPayload::_internal_has_shortconnect() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool ClientPayload::has_shortconnect() const {
  return _internal_has_shortconnect();
}
inline void ClientPayload::clear_shortconnect() {
  _impl_.shortconnect_ = false;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline bool ClientPayload::_internal_shortconnect() const {
  return _impl_.shortconnect_;
}
inline bool ClientPayload::shortconnect() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.shortConnect)
  return _internal_shortconnect();
}
inline void ClientPayload::_internal_set_shortconnect(bool value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.shortconnect_ = value;
}
inline void ClientPayload::set_shortconnect(bool value) {
  _internal_set_shortconnect(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.shortConnect)
}

// optional .proto.ClientPayload.ConnectType connectType = 12;
inline bool ClientPayload::_internal_has_connecttype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ClientPayload::has_connecttype() const {
  return _internal_has_connecttype();
}
inline void ClientPayload::clear_connecttype() {
  _impl_.connecttype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::proto::ClientPayload_ConnectType ClientPayload::_internal_connecttype() const {
  return static_cast< ::proto::ClientPayload_ConnectType >(_impl_.connecttype_);
}
inline ::proto::ClientPayload_ConnectType ClientPayload::connecttype() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectType)
  return _internal_connecttype();
}
inline void ClientPayload::_internal_set_connecttype(::proto::ClientPayload_ConnectType value) {
  assert(::proto::ClientPayload_ConnectType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.connecttype_ = value;
}
inline void ClientPayload::set_connecttype(::proto::ClientPayload_ConnectType value) {
  _internal_set_connecttype(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectType)
}

// optional .proto.ClientPayload.ConnectReason connectReason = 13;
inline bool ClientPayload::_internal_has_connectreason() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool ClientPayload::has_connectreason() const {
  return _internal_has_connectreason();
}
inline void ClientPayload::clear_connectreason() {
  _impl_.connectreason_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::proto::ClientPayload_ConnectReason ClientPayload::_internal_connectreason() const {
  return static_cast< ::proto::ClientPayload_ConnectReason >(_impl_.connectreason_);
}
inline ::proto::ClientPayload_ConnectReason ClientPayload::connectreason() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectReason)
  return _internal_connectreason();
}
inline void ClientPayload::_internal_set_connectreason(::proto::ClientPayload_ConnectReason value) {
  assert(::proto::ClientPayload_ConnectReason_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.connectreason_ = value;
}
inline void ClientPayload::set_connectreason(::proto::ClientPayload_ConnectReason value) {
  _internal_set_connectreason(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectReason)
}

// repeated int32 shards = 14;
inline int ClientPayload::_internal_shards_size() const {
  return _impl_.shards_.size();
}
inline int ClientPayload::shards_size() const {
  return _internal_shards_size();
}
inline void ClientPayload::clear_shards() {
  _impl_.shards_.Clear();
}
inline int32_t ClientPayload::_internal_shards(int index) const {
  return _impl_.shards_.Get(index);
}
inline int32_t ClientPayload::shards(int index) const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.shards)
  return _internal_shards(index);
}
inline void ClientPayload::set_shards(int index, int32_t value) {
  _impl_.shards_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.shards)
}
inline void ClientPayload::_internal_add_shards(int32_t value) {
  _impl_.shards_.Add(value);
}
inline void ClientPayload::add_shards(int32_t value) {
  _internal_add_shards(value);
  // @@protoc_insertion_point(field_add:proto.ClientPayload.shards)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ClientPayload::_internal_shards() const {
  return _impl_.shards_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ClientPayload::shards() const {
  // @@protoc_insertion_point(field_list:proto.ClientPayload.shards)
  return _internal_shards();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ClientPayload::_internal_mutable_shards() {
  return &_impl_.shards_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ClientPayload::mutable_shards() {
  // @@protoc_insertion_point(field_mutable_list:proto.ClientPayload.shards)
  return _internal_mutable_shards();
}

// optional .proto.ClientPayload.DNSSource dnsSource = 15;
inline bool ClientPayload::_internal_has_dnssource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dnssource_ != nullptr);
  return value;
}
inline bool ClientPayload::has_dnssource() const {
  return _internal_has_dnssource();
}
inline void ClientPayload::clear_dnssource() {
  if (_impl_.dnssource_ != nullptr) _impl_.dnssource_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::ClientPayload_DNSSource& ClientPayload::_internal_dnssource() const {
  const ::proto::ClientPayload_DNSSource* p = _impl_.dnssource_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_DNSSource&>(
      ::proto::_ClientPayload_DNSSource_default_instance_);
}
inline const ::proto::ClientPayload_DNSSource& ClientPayload::dnssource() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.dnsSource)
  return _internal_dnssource();
}
inline void ClientPayload::unsafe_arena_set_allocated_dnssource(
    ::proto::ClientPayload_DNSSource* dnssource) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dnssource_);
  }
  _impl_.dnssource_ = dnssource;
  if (dnssource) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.dnsSource)
}
inline ::proto::ClientPayload_DNSSource* ClientPayload::release_dnssource() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_;
  _impl_.dnssource_ = 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 ::proto::ClientPayload_DNSSource* ClientPayload::unsafe_arena_release_dnssource() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.dnsSource)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::ClientPayload_DNSSource* temp = _impl_.dnssource_;
  _impl_.dnssource_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_DNSSource* ClientPayload::_internal_mutable_dnssource() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.dnssource_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_DNSSource>(GetArenaForAllocation());
    _impl_.dnssource_ = p;
  }
  return _impl_.dnssource_;
}
inline ::proto::ClientPayload_DNSSource* ClientPayload::mutable_dnssource() {
  ::proto::ClientPayload_DNSSource* _msg = _internal_mutable_dnssource();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.dnsSource)
  return _msg;
}
inline void ClientPayload::set_allocated_dnssource(::proto::ClientPayload_DNSSource* dnssource) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.dnssource_;
  }
  if (dnssource) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(dnssource);
    if (message_arena != submessage_arena) {
      dnssource = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dnssource, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.dnssource_ = dnssource;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.dnsSource)
}

// optional uint32 connectAttemptCount = 16;
inline bool ClientPayload::_internal_has_connectattemptcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool ClientPayload::has_connectattemptcount() const {
  return _internal_has_connectattemptcount();
}
inline void ClientPayload::clear_connectattemptcount() {
  _impl_.connectattemptcount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t ClientPayload::_internal_connectattemptcount() const {
  return _impl_.connectattemptcount_;
}
inline uint32_t ClientPayload::connectattemptcount() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.connectAttemptCount)
  return _internal_connectattemptcount();
}
inline void ClientPayload::_internal_set_connectattemptcount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.connectattemptcount_ = value;
}
inline void ClientPayload::set_connectattemptcount(uint32_t value) {
  _internal_set_connectattemptcount(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.connectAttemptCount)
}

// optional uint32 device = 18;
inline bool ClientPayload::_internal_has_device() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool ClientPayload::has_device() const {
  return _internal_has_device();
}
inline void ClientPayload::clear_device() {
  _impl_.device_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t ClientPayload::_internal_device() const {
  return _impl_.device_;
}
inline uint32_t ClientPayload::device() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.device)
  return _internal_device();
}
inline void ClientPayload::_internal_set_device(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.device_ = value;
}
inline void ClientPayload::set_device(uint32_t value) {
  _internal_set_device(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.device)
}

// optional .proto.ClientPayload.DevicePairingRegistrationData devicePairingData = 19;
inline bool ClientPayload::_internal_has_devicepairingdata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.devicepairingdata_ != nullptr);
  return value;
}
inline bool ClientPayload::has_devicepairingdata() const {
  return _internal_has_devicepairingdata();
}
inline void ClientPayload::clear_devicepairingdata() {
  if (_impl_.devicepairingdata_ != nullptr) _impl_.devicepairingdata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::_internal_devicepairingdata() const {
  const ::proto::ClientPayload_DevicePairingRegistrationData* p = _impl_.devicepairingdata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ClientPayload_DevicePairingRegistrationData&>(
      ::proto::_ClientPayload_DevicePairingRegistrationData_default_instance_);
}
inline const ::proto::ClientPayload_DevicePairingRegistrationData& ClientPayload::devicepairingdata() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.devicePairingData)
  return _internal_devicepairingdata();
}
inline void ClientPayload::unsafe_arena_set_allocated_devicepairingdata(
    ::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicepairingdata_);
  }
  _impl_.devicepairingdata_ = devicepairingdata;
  if (devicepairingdata) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ClientPayload.devicePairingData)
}
inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::release_devicepairingdata() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_;
  _impl_.devicepairingdata_ = 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 ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::unsafe_arena_release_devicepairingdata() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.devicePairingData)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ClientPayload_DevicePairingRegistrationData* temp = _impl_.devicepairingdata_;
  _impl_.devicepairingdata_ = nullptr;
  return temp;
}
inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::_internal_mutable_devicepairingdata() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.devicepairingdata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ClientPayload_DevicePairingRegistrationData>(GetArenaForAllocation());
    _impl_.devicepairingdata_ = p;
  }
  return _impl_.devicepairingdata_;
}
inline ::proto::ClientPayload_DevicePairingRegistrationData* ClientPayload::mutable_devicepairingdata() {
  ::proto::ClientPayload_DevicePairingRegistrationData* _msg = _internal_mutable_devicepairingdata();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.devicePairingData)
  return _msg;
}
inline void ClientPayload::set_allocated_devicepairingdata(::proto::ClientPayload_DevicePairingRegistrationData* devicepairingdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.devicepairingdata_;
  }
  if (devicepairingdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicepairingdata);
    if (message_arena != submessage_arena) {
      devicepairingdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, devicepairingdata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.devicepairingdata_ = devicepairingdata;
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.devicePairingData)
}

// optional .proto.ClientPayload.Product product = 20;
inline bool ClientPayload::_internal_has_product() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool ClientPayload::has_product() const {
  return _internal_has_product();
}
inline void ClientPayload::clear_product() {
  _impl_.product_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline ::proto::ClientPayload_Product ClientPayload::_internal_product() const {
  return static_cast< ::proto::ClientPayload_Product >(_impl_.product_);
}
inline ::proto::ClientPayload_Product ClientPayload::product() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.product)
  return _internal_product();
}
inline void ClientPayload::_internal_set_product(::proto::ClientPayload_Product value) {
  assert(::proto::ClientPayload_Product_IsValid(value));
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.product_ = value;
}
inline void ClientPayload::set_product(::proto::ClientPayload_Product value) {
  _internal_set_product(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.product)
}

// optional bytes fbCat = 21;
inline bool ClientPayload::_internal_has_fbcat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ClientPayload::has_fbcat() const {
  return _internal_has_fbcat();
}
inline void ClientPayload::clear_fbcat() {
  _impl_.fbcat_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ClientPayload::fbcat() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbCat)
  return _internal_fbcat();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload::set_fbcat(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.fbcat_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbCat)
}
inline std::string* ClientPayload::mutable_fbcat() {
  std::string* _s = _internal_mutable_fbcat();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbCat)
  return _s;
}
inline const std::string& ClientPayload::_internal_fbcat() const {
  return _impl_.fbcat_.Get();
}
inline void ClientPayload::_internal_set_fbcat(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.fbcat_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload::_internal_mutable_fbcat() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.fbcat_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload::release_fbcat() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbCat)
  if (!_internal_has_fbcat()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.fbcat_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbcat_.IsDefault()) {
    _impl_.fbcat_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload::set_allocated_fbcat(std::string* fbcat) {
  if (fbcat != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.fbcat_.SetAllocated(fbcat, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbcat_.IsDefault()) {
    _impl_.fbcat_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbCat)
}

// optional bytes fbUserAgent = 22;
inline bool ClientPayload::_internal_has_fbuseragent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ClientPayload::has_fbuseragent() const {
  return _internal_has_fbuseragent();
}
inline void ClientPayload::clear_fbuseragent() {
  _impl_.fbuseragent_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ClientPayload::fbuseragent() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbUserAgent)
  return _internal_fbuseragent();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload::set_fbuseragent(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fbuseragent_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbUserAgent)
}
inline std::string* ClientPayload::mutable_fbuseragent() {
  std::string* _s = _internal_mutable_fbuseragent();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbUserAgent)
  return _s;
}
inline const std::string& ClientPayload::_internal_fbuseragent() const {
  return _impl_.fbuseragent_.Get();
}
inline void ClientPayload::_internal_set_fbuseragent(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fbuseragent_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload::_internal_mutable_fbuseragent() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fbuseragent_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload::release_fbuseragent() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbUserAgent)
  if (!_internal_has_fbuseragent()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fbuseragent_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbuseragent_.IsDefault()) {
    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload::set_allocated_fbuseragent(std::string* fbuseragent) {
  if (fbuseragent != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fbuseragent_.SetAllocated(fbuseragent, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbuseragent_.IsDefault()) {
    _impl_.fbuseragent_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbUserAgent)
}

// optional bool oc = 23;
inline bool ClientPayload::_internal_has_oc() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool ClientPayload::has_oc() const {
  return _internal_has_oc();
}
inline void ClientPayload::clear_oc() {
  _impl_.oc_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool ClientPayload::_internal_oc() const {
  return _impl_.oc_;
}
inline bool ClientPayload::oc() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.oc)
  return _internal_oc();
}
inline void ClientPayload::_internal_set_oc(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.oc_ = value;
}
inline void ClientPayload::set_oc(bool value) {
  _internal_set_oc(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.oc)
}

// optional int32 lc = 24;
inline bool ClientPayload::_internal_has_lc() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool ClientPayload::has_lc() const {
  return _internal_has_lc();
}
inline void ClientPayload::clear_lc() {
  _impl_.lc_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int32_t ClientPayload::_internal_lc() const {
  return _impl_.lc_;
}
inline int32_t ClientPayload::lc() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.lc)
  return _internal_lc();
}
inline void ClientPayload::_internal_set_lc(int32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.lc_ = value;
}
inline void ClientPayload::set_lc(int32_t value) {
  _internal_set_lc(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.lc)
}

// optional .proto.ClientPayload.IOSAppExtension iosAppExtension = 30;
inline bool ClientPayload::_internal_has_iosappextension() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool ClientPayload::has_iosappextension() const {
  return _internal_has_iosappextension();
}
inline void ClientPayload::clear_iosappextension() {
  _impl_.iosappextension_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline ::proto::ClientPayload_IOSAppExtension ClientPayload::_internal_iosappextension() const {
  return static_cast< ::proto::ClientPayload_IOSAppExtension >(_impl_.iosappextension_);
}
inline ::proto::ClientPayload_IOSAppExtension ClientPayload::iosappextension() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.iosAppExtension)
  return _internal_iosappextension();
}
inline void ClientPayload::_internal_set_iosappextension(::proto::ClientPayload_IOSAppExtension value) {
  assert(::proto::ClientPayload_IOSAppExtension_IsValid(value));
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.iosappextension_ = value;
}
inline void ClientPayload::set_iosappextension(::proto::ClientPayload_IOSAppExtension value) {
  _internal_set_iosappextension(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.iosAppExtension)
}

// optional uint64 fbAppId = 31;
inline bool ClientPayload::_internal_has_fbappid() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool ClientPayload::has_fbappid() const {
  return _internal_has_fbappid();
}
inline void ClientPayload::clear_fbappid() {
  _impl_.fbappid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint64_t ClientPayload::_internal_fbappid() const {
  return _impl_.fbappid_;
}
inline uint64_t ClientPayload::fbappid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbAppId)
  return _internal_fbappid();
}
inline void ClientPayload::_internal_set_fbappid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.fbappid_ = value;
}
inline void ClientPayload::set_fbappid(uint64_t value) {
  _internal_set_fbappid(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbAppId)
}

// optional bytes fbDeviceId = 32;
inline bool ClientPayload::_internal_has_fbdeviceid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ClientPayload::has_fbdeviceid() const {
  return _internal_has_fbdeviceid();
}
inline void ClientPayload::clear_fbdeviceid() {
  _impl_.fbdeviceid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ClientPayload::fbdeviceid() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.fbDeviceId)
  return _internal_fbdeviceid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload::set_fbdeviceid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.fbdeviceid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.fbDeviceId)
}
inline std::string* ClientPayload::mutable_fbdeviceid() {
  std::string* _s = _internal_mutable_fbdeviceid();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.fbDeviceId)
  return _s;
}
inline const std::string& ClientPayload::_internal_fbdeviceid() const {
  return _impl_.fbdeviceid_.Get();
}
inline void ClientPayload::_internal_set_fbdeviceid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.fbdeviceid_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload::_internal_mutable_fbdeviceid() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.fbdeviceid_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload::release_fbdeviceid() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.fbDeviceId)
  if (!_internal_has_fbdeviceid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.fbdeviceid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbdeviceid_.IsDefault()) {
    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload::set_allocated_fbdeviceid(std::string* fbdeviceid) {
  if (fbdeviceid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.fbdeviceid_.SetAllocated(fbdeviceid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fbdeviceid_.IsDefault()) {
    _impl_.fbdeviceid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.fbDeviceId)
}

// optional bool pull = 33;
inline bool ClientPayload::_internal_has_pull() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool ClientPayload::has_pull() const {
  return _internal_has_pull();
}
inline void ClientPayload::clear_pull() {
  _impl_.pull_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool ClientPayload::_internal_pull() const {
  return _impl_.pull_;
}
inline bool ClientPayload::pull() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.pull)
  return _internal_pull();
}
inline void ClientPayload::_internal_set_pull(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.pull_ = value;
}
inline void ClientPayload::set_pull(bool value) {
  _internal_set_pull(value);
  // @@protoc_insertion_point(field_set:proto.ClientPayload.pull)
}

// optional bytes paddingBytes = 34;
inline bool ClientPayload::_internal_has_paddingbytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ClientPayload::has_paddingbytes() const {
  return _internal_has_paddingbytes();
}
inline void ClientPayload::clear_paddingbytes() {
  _impl_.paddingbytes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ClientPayload::paddingbytes() const {
  // @@protoc_insertion_point(field_get:proto.ClientPayload.paddingBytes)
  return _internal_paddingbytes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ClientPayload::set_paddingbytes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.paddingbytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ClientPayload.paddingBytes)
}
inline std::string* ClientPayload::mutable_paddingbytes() {
  std::string* _s = _internal_mutable_paddingbytes();
  // @@protoc_insertion_point(field_mutable:proto.ClientPayload.paddingBytes)
  return _s;
}
inline const std::string& ClientPayload::_internal_paddingbytes() const {
  return _impl_.paddingbytes_.Get();
}
inline void ClientPayload::_internal_set_paddingbytes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.paddingbytes_.Set(value, GetArenaForAllocation());
}
inline std::string* ClientPayload::_internal_mutable_paddingbytes() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.paddingbytes_.Mutable(GetArenaForAllocation());
}
inline std::string* ClientPayload::release_paddingbytes() {
  // @@protoc_insertion_point(field_release:proto.ClientPayload.paddingBytes)
  if (!_internal_has_paddingbytes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.paddingbytes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paddingbytes_.IsDefault()) {
    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ClientPayload::set_allocated_paddingbytes(std::string* paddingbytes) {
  if (paddingbytes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paddingbytes_.IsDefault()) {
    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ClientPayload.paddingBytes)
}

// -------------------------------------------------------------------

// ContextInfo_AdReplyInfo

// optional string advertiserName = 1;
inline bool ContextInfo_AdReplyInfo::_internal_has_advertisername() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ContextInfo_AdReplyInfo::has_advertisername() const {
  return _internal_has_advertisername();
}
inline void ContextInfo_AdReplyInfo::clear_advertisername() {
  _impl_.advertisername_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ContextInfo_AdReplyInfo::advertisername() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.advertiserName)
  return _internal_advertisername();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_AdReplyInfo::set_advertisername(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.advertisername_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.advertiserName)
}
inline std::string* ContextInfo_AdReplyInfo::mutable_advertisername() {
  std::string* _s = _internal_mutable_advertisername();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.advertiserName)
  return _s;
}
inline const std::string& ContextInfo_AdReplyInfo::_internal_advertisername() const {
  return _impl_.advertisername_.Get();
}
inline void ContextInfo_AdReplyInfo::_internal_set_advertisername(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.advertisername_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_advertisername() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.advertisername_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::release_advertisername() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.advertiserName)
  if (!_internal_has_advertisername()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.advertisername_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.advertisername_.IsDefault()) {
    _impl_.advertisername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_AdReplyInfo::set_allocated_advertisername(std::string* advertisername) {
  if (advertisername != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.advertisername_.SetAllocated(advertisername, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.advertisername_.IsDefault()) {
    _impl_.advertisername_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.advertiserName)
}

// optional .proto.ContextInfo.AdReplyInfo.MediaType mediaType = 2;
inline bool ContextInfo_AdReplyInfo::_internal_has_mediatype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ContextInfo_AdReplyInfo::has_mediatype() const {
  return _internal_has_mediatype();
}
inline void ContextInfo_AdReplyInfo::clear_mediatype() {
  _impl_.mediatype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::_internal_mediatype() const {
  return static_cast< ::proto::ContextInfo_AdReplyInfo_MediaType >(_impl_.mediatype_);
}
inline ::proto::ContextInfo_AdReplyInfo_MediaType ContextInfo_AdReplyInfo::mediatype() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.mediaType)
  return _internal_mediatype();
}
inline void ContextInfo_AdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) {
  assert(::proto::ContextInfo_AdReplyInfo_MediaType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediatype_ = value;
}
inline void ContextInfo_AdReplyInfo::set_mediatype(::proto::ContextInfo_AdReplyInfo_MediaType value) {
  _internal_set_mediatype(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.mediaType)
}

// optional bytes jpegThumbnail = 16;
inline bool ContextInfo_AdReplyInfo::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ContextInfo_AdReplyInfo::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void ContextInfo_AdReplyInfo::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ContextInfo_AdReplyInfo::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_AdReplyInfo::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
}
inline std::string* ContextInfo_AdReplyInfo::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
  return _s;
}
inline const std::string& ContextInfo_AdReplyInfo::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void ContextInfo_AdReplyInfo::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_AdReplyInfo::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.AdReplyInfo.jpegThumbnail)
}

// optional string caption = 17;
inline bool ContextInfo_AdReplyInfo::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ContextInfo_AdReplyInfo::has_caption() const {
  return _internal_has_caption();
}
inline void ContextInfo_AdReplyInfo::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ContextInfo_AdReplyInfo::caption() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.AdReplyInfo.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_AdReplyInfo::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.AdReplyInfo.caption)
}
inline std::string* ContextInfo_AdReplyInfo::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.AdReplyInfo.caption)
  return _s;
}
inline const std::string& ContextInfo_AdReplyInfo::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void ContextInfo_AdReplyInfo::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_AdReplyInfo::release_caption() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.AdReplyInfo.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  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 ContextInfo_AdReplyInfo::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _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:proto.ContextInfo.AdReplyInfo.caption)
}

// -------------------------------------------------------------------

// ContextInfo_ExternalAdReplyInfo

// optional string title = 1;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_title() const {
  return _internal_has_title();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::title() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.title)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.title)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_title() const {
  return _impl_.title_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_title() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 ContextInfo_ExternalAdReplyInfo::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.ContextInfo.ExternalAdReplyInfo.title)
}

// optional string body = 2;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_body() const {
  return _internal_has_body();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_body() {
  _impl_.body_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::body() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_body(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.body)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.body)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_body() const {
  return _impl_.body_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_body(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.body_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.body_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_body() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.body)
  if (!_internal_has_body()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 ContextInfo_ExternalAdReplyInfo::set_allocated_body(std::string* body) {
  if (body != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:proto.ContextInfo.ExternalAdReplyInfo.body)
}

// optional .proto.ContextInfo.ExternalAdReplyInfo.MediaType mediaType = 3;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediatype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_mediatype() const {
  return _internal_has_mediatype();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_mediatype() {
  _impl_.mediatype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::_internal_mediatype() const {
  return static_cast< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType >(_impl_.mediatype_);
}
inline ::proto::ContextInfo_ExternalAdReplyInfo_MediaType ContextInfo_ExternalAdReplyInfo::mediatype() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaType)
  return _internal_mediatype();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) {
  assert(::proto::ContextInfo_ExternalAdReplyInfo_MediaType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.mediatype_ = value;
}
inline void ContextInfo_ExternalAdReplyInfo::set_mediatype(::proto::ContextInfo_ExternalAdReplyInfo_MediaType value) {
  _internal_set_mediatype(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaType)
}

// optional string thumbnailUrl = 4;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnailurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnailurl() const {
  return _internal_has_thumbnailurl();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnailurl() {
  _impl_.thumbnailurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnailurl() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
  return _internal_thumbnailurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_thumbnailurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.thumbnailurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnailurl() {
  std::string* _s = _internal_mutable_thumbnailurl();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnailurl() const {
  return _impl_.thumbnailurl_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnailurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.thumbnailurl_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnailurl() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.thumbnailurl_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnailurl() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
  if (!_internal_has_thumbnailurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.thumbnailurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailurl_.IsDefault()) {
    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnailurl(std::string* thumbnailurl) {
  if (thumbnailurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.thumbnailurl_.SetAllocated(thumbnailurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailurl_.IsDefault()) {
    _impl_.thumbnailurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.thumbnailUrl)
}

// optional string mediaUrl = 5;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_mediaurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_mediaurl() const {
  return _internal_has_mediaurl();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_mediaurl() {
  _impl_.mediaurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::mediaurl() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
  return _internal_mediaurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_mediaurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mediaurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_mediaurl() {
  std::string* _s = _internal_mutable_mediaurl();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_mediaurl() const {
  return _impl_.mediaurl_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_mediaurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediaurl_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_mediaurl() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mediaurl_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_mediaurl() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
  if (!_internal_has_mediaurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mediaurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediaurl_.IsDefault()) {
    _impl_.mediaurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_ExternalAdReplyInfo::set_allocated_mediaurl(std::string* mediaurl) {
  if (mediaurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mediaurl_.SetAllocated(mediaurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediaurl_.IsDefault()) {
    _impl_.mediaurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.mediaUrl)
}

// optional bytes thumbnail = 6;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_thumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_thumbnail() const {
  return _internal_has_thumbnail();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_thumbnail() {
  _impl_.thumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::thumbnail() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
  return _internal_thumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_thumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.thumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_thumbnail() {
  std::string* _s = _internal_mutable_thumbnail();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_thumbnail() const {
  return _impl_.thumbnail_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_thumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.thumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_thumbnail() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.thumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_thumbnail() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
  if (!_internal_has_thumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  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 ContextInfo_ExternalAdReplyInfo::set_allocated_thumbnail(std::string* thumbnail) {
  if (thumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _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:proto.ContextInfo.ExternalAdReplyInfo.thumbnail)
}

// optional string sourceType = 7;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourcetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_sourcetype() const {
  return _internal_has_sourcetype();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_sourcetype() {
  _impl_.sourcetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::sourcetype() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
  return _internal_sourcetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_sourcetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.sourcetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourcetype() {
  std::string* _s = _internal_mutable_sourcetype();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourcetype() const {
  return _impl_.sourcetype_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourcetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.sourcetype_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourcetype() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.sourcetype_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourcetype() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
  if (!_internal_has_sourcetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.sourcetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourcetype_.IsDefault()) {
    _impl_.sourcetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourcetype(std::string* sourcetype) {
  if (sourcetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.sourcetype_.SetAllocated(sourcetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourcetype_.IsDefault()) {
    _impl_.sourcetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceType)
}

// optional string sourceId = 8;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_sourceid() const {
  return _internal_has_sourceid();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_sourceid() {
  _impl_.sourceid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceid() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
  return _internal_sourceid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_sourceid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.sourceid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceid() {
  std::string* _s = _internal_mutable_sourceid();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceid() const {
  return _impl_.sourceid_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.sourceid_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceid() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.sourceid_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceid() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
  if (!_internal_has_sourceid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.sourceid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceid_.IsDefault()) {
    _impl_.sourceid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceid(std::string* sourceid) {
  if (sourceid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.sourceid_.SetAllocated(sourceid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceid_.IsDefault()) {
    _impl_.sourceid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceId)
}

// optional string sourceUrl = 9;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_sourceurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_sourceurl() const {
  return _internal_has_sourceurl();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_sourceurl() {
  _impl_.sourceurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::sourceurl() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
  return _internal_sourceurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo_ExternalAdReplyInfo::set_sourceurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.sourceurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
}
inline std::string* ContextInfo_ExternalAdReplyInfo::mutable_sourceurl() {
  std::string* _s = _internal_mutable_sourceurl();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
  return _s;
}
inline const std::string& ContextInfo_ExternalAdReplyInfo::_internal_sourceurl() const {
  return _impl_.sourceurl_.Get();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_sourceurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.sourceurl_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::_internal_mutable_sourceurl() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.sourceurl_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo_ExternalAdReplyInfo::release_sourceurl() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
  if (!_internal_has_sourceurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.sourceurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceurl_.IsDefault()) {
    _impl_.sourceurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo_ExternalAdReplyInfo::set_allocated_sourceurl(std::string* sourceurl) {
  if (sourceurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.sourceurl_.SetAllocated(sourceurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sourceurl_.IsDefault()) {
    _impl_.sourceurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ExternalAdReplyInfo.sourceUrl)
}

// optional bool containsAutoReply = 10;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_containsautoreply() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_containsautoreply() const {
  return _internal_has_containsautoreply();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_containsautoreply() {
  _impl_.containsautoreply_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool ContextInfo_ExternalAdReplyInfo::_internal_containsautoreply() const {
  return _impl_.containsautoreply_;
}
inline bool ContextInfo_ExternalAdReplyInfo::containsautoreply() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply)
  return _internal_containsautoreply();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_containsautoreply(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.containsautoreply_ = value;
}
inline void ContextInfo_ExternalAdReplyInfo::set_containsautoreply(bool value) {
  _internal_set_containsautoreply(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.containsAutoReply)
}

// optional bool renderLargerThumbnail = 11;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_renderlargerthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_renderlargerthumbnail() const {
  return _internal_has_renderlargerthumbnail();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_renderlargerthumbnail() {
  _impl_.renderlargerthumbnail_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool ContextInfo_ExternalAdReplyInfo::_internal_renderlargerthumbnail() const {
  return _impl_.renderlargerthumbnail_;
}
inline bool ContextInfo_ExternalAdReplyInfo::renderlargerthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail)
  return _internal_renderlargerthumbnail();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_renderlargerthumbnail(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.renderlargerthumbnail_ = value;
}
inline void ContextInfo_ExternalAdReplyInfo::set_renderlargerthumbnail(bool value) {
  _internal_set_renderlargerthumbnail(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.renderLargerThumbnail)
}

// optional bool showAdAttribution = 12;
inline bool ContextInfo_ExternalAdReplyInfo::_internal_has_showadattribution() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool ContextInfo_ExternalAdReplyInfo::has_showadattribution() const {
  return _internal_has_showadattribution();
}
inline void ContextInfo_ExternalAdReplyInfo::clear_showadattribution() {
  _impl_.showadattribution_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool ContextInfo_ExternalAdReplyInfo::_internal_showadattribution() const {
  return _impl_.showadattribution_;
}
inline bool ContextInfo_ExternalAdReplyInfo::showadattribution() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution)
  return _internal_showadattribution();
}
inline void ContextInfo_ExternalAdReplyInfo::_internal_set_showadattribution(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.showadattribution_ = value;
}
inline void ContextInfo_ExternalAdReplyInfo::set_showadattribution(bool value) {
  _internal_set_showadattribution(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ExternalAdReplyInfo.showAdAttribution)
}

// -------------------------------------------------------------------

// ContextInfo

// optional string stanzaId = 1;
inline bool ContextInfo::_internal_has_stanzaid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ContextInfo::has_stanzaid() const {
  return _internal_has_stanzaid();
}
inline void ContextInfo::clear_stanzaid() {
  _impl_.stanzaid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ContextInfo::stanzaid() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.stanzaId)
  return _internal_stanzaid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_stanzaid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.stanzaId)
}
inline std::string* ContextInfo::mutable_stanzaid() {
  std::string* _s = _internal_mutable_stanzaid();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.stanzaId)
  return _s;
}
inline const std::string& ContextInfo::_internal_stanzaid() const {
  return _impl_.stanzaid_.Get();
}
inline void ContextInfo::_internal_set_stanzaid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_stanzaid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_stanzaid() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.stanzaId)
  if (!_internal_has_stanzaid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.stanzaid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_stanzaid(std::string* stanzaid) {
  if (stanzaid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.stanzaId)
}

// optional string participant = 2;
inline bool ContextInfo::_internal_has_participant() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ContextInfo::has_participant() const {
  return _internal_has_participant();
}
inline void ContextInfo::clear_participant() {
  _impl_.participant_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ContextInfo::participant() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.participant)
  return _internal_participant();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_participant(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.participant)
}
inline std::string* ContextInfo::mutable_participant() {
  std::string* _s = _internal_mutable_participant();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.participant)
  return _s;
}
inline const std::string& ContextInfo::_internal_participant() const {
  return _impl_.participant_.Get();
}
inline void ContextInfo::_internal_set_participant(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.participant_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_participant() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.participant_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_participant() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.participant)
  if (!_internal_has_participant()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.participant_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_participant(std::string* participant) {
  if (participant != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.participant)
}

// optional .proto.Message quotedMessage = 3;
inline bool ContextInfo::_internal_has_quotedmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quotedmessage_ != nullptr);
  return value;
}
inline bool ContextInfo::has_quotedmessage() const {
  return _internal_has_quotedmessage();
}
inline void ContextInfo::clear_quotedmessage() {
  if (_impl_.quotedmessage_ != nullptr) _impl_.quotedmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::proto::Message& ContextInfo::_internal_quotedmessage() const {
  const ::proto::Message* p = _impl_.quotedmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& ContextInfo::quotedmessage() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedMessage)
  return _internal_quotedmessage();
}
inline void ContextInfo::unsafe_arena_set_allocated_quotedmessage(
    ::proto::Message* quotedmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmessage_);
  }
  _impl_.quotedmessage_ = quotedmessage;
  if (quotedmessage) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedMessage)
}
inline ::proto::Message* ContextInfo::release_quotedmessage() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::Message* temp = _impl_.quotedmessage_;
  _impl_.quotedmessage_ = 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 ::proto::Message* ContextInfo::unsafe_arena_release_quotedmessage() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedMessage)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::Message* temp = _impl_.quotedmessage_;
  _impl_.quotedmessage_ = nullptr;
  return temp;
}
inline ::proto::Message* ContextInfo::_internal_mutable_quotedmessage() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.quotedmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.quotedmessage_ = p;
  }
  return _impl_.quotedmessage_;
}
inline ::proto::Message* ContextInfo::mutable_quotedmessage() {
  ::proto::Message* _msg = _internal_mutable_quotedmessage();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedMessage)
  return _msg;
}
inline void ContextInfo::set_allocated_quotedmessage(::proto::Message* quotedmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quotedmessage_;
  }
  if (quotedmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmessage);
    if (message_arena != submessage_arena) {
      quotedmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quotedmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.quotedmessage_ = quotedmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedMessage)
}

// optional string remoteJid = 4;
inline bool ContextInfo::_internal_has_remotejid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ContextInfo::has_remotejid() const {
  return _internal_has_remotejid();
}
inline void ContextInfo::clear_remotejid() {
  _impl_.remotejid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ContextInfo::remotejid() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.remoteJid)
  return _internal_remotejid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_remotejid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.remotejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.remoteJid)
}
inline std::string* ContextInfo::mutable_remotejid() {
  std::string* _s = _internal_mutable_remotejid();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.remoteJid)
  return _s;
}
inline const std::string& ContextInfo::_internal_remotejid() const {
  return _impl_.remotejid_.Get();
}
inline void ContextInfo::_internal_set_remotejid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.remotejid_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_remotejid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.remotejid_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_remotejid() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.remoteJid)
  if (!_internal_has_remotejid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.remotejid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remotejid_.IsDefault()) {
    _impl_.remotejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_remotejid(std::string* remotejid) {
  if (remotejid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remotejid_.IsDefault()) {
    _impl_.remotejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.remoteJid)
}

// repeated string mentionedJid = 15;
inline int ContextInfo::_internal_mentionedjid_size() const {
  return _impl_.mentionedjid_.size();
}
inline int ContextInfo::mentionedjid_size() const {
  return _internal_mentionedjid_size();
}
inline void ContextInfo::clear_mentionedjid() {
  _impl_.mentionedjid_.Clear();
}
inline std::string* ContextInfo::add_mentionedjid() {
  std::string* _s = _internal_add_mentionedjid();
  // @@protoc_insertion_point(field_add_mutable:proto.ContextInfo.mentionedJid)
  return _s;
}
inline const std::string& ContextInfo::_internal_mentionedjid(int index) const {
  return _impl_.mentionedjid_.Get(index);
}
inline const std::string& ContextInfo::mentionedjid(int index) const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.mentionedJid)
  return _internal_mentionedjid(index);
}
inline std::string* ContextInfo::mutable_mentionedjid(int index) {
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.mentionedJid)
  return _impl_.mentionedjid_.Mutable(index);
}
inline void ContextInfo::set_mentionedjid(int index, const std::string& value) {
  _impl_.mentionedjid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::set_mentionedjid(int index, std::string&& value) {
  _impl_.mentionedjid_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::set_mentionedjid(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.mentionedjid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::set_mentionedjid(int index, const char* value, size_t size) {
  _impl_.mentionedjid_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.ContextInfo.mentionedJid)
}
inline std::string* ContextInfo::_internal_add_mentionedjid() {
  return _impl_.mentionedjid_.Add();
}
inline void ContextInfo::add_mentionedjid(const std::string& value) {
  _impl_.mentionedjid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::add_mentionedjid(std::string&& value) {
  _impl_.mentionedjid_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::add_mentionedjid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.mentionedjid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.ContextInfo.mentionedJid)
}
inline void ContextInfo::add_mentionedjid(const char* value, size_t size) {
  _impl_.mentionedjid_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.ContextInfo.mentionedJid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ContextInfo::mentionedjid() const {
  // @@protoc_insertion_point(field_list:proto.ContextInfo.mentionedJid)
  return _impl_.mentionedjid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
ContextInfo::mutable_mentionedjid() {
  // @@protoc_insertion_point(field_mutable_list:proto.ContextInfo.mentionedJid)
  return &_impl_.mentionedjid_;
}

// optional string conversionSource = 18;
inline bool ContextInfo::_internal_has_conversionsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ContextInfo::has_conversionsource() const {
  return _internal_has_conversionsource();
}
inline void ContextInfo::clear_conversionsource() {
  _impl_.conversionsource_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ContextInfo::conversionsource() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionSource)
  return _internal_conversionsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_conversionsource(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.conversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionSource)
}
inline std::string* ContextInfo::mutable_conversionsource() {
  std::string* _s = _internal_mutable_conversionsource();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionSource)
  return _s;
}
inline const std::string& ContextInfo::_internal_conversionsource() const {
  return _impl_.conversionsource_.Get();
}
inline void ContextInfo::_internal_set_conversionsource(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.conversionsource_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_conversionsource() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.conversionsource_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_conversionsource() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionSource)
  if (!_internal_has_conversionsource()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.conversionsource_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversionsource_.IsDefault()) {
    _impl_.conversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_conversionsource(std::string* conversionsource) {
  if (conversionsource != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversionsource_.IsDefault()) {
    _impl_.conversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionSource)
}

// optional bytes conversionData = 19;
inline bool ContextInfo::_internal_has_conversiondata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ContextInfo::has_conversiondata() const {
  return _internal_has_conversiondata();
}
inline void ContextInfo::clear_conversiondata() {
  _impl_.conversiondata_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ContextInfo::conversiondata() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionData)
  return _internal_conversiondata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_conversiondata(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.conversiondata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionData)
}
inline std::string* ContextInfo::mutable_conversiondata() {
  std::string* _s = _internal_mutable_conversiondata();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.conversionData)
  return _s;
}
inline const std::string& ContextInfo::_internal_conversiondata() const {
  return _impl_.conversiondata_.Get();
}
inline void ContextInfo::_internal_set_conversiondata(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.conversiondata_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_conversiondata() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.conversiondata_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_conversiondata() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.conversionData)
  if (!_internal_has_conversiondata()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.conversiondata_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversiondata_.IsDefault()) {
    _impl_.conversiondata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_conversiondata(std::string* conversiondata) {
  if (conversiondata != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversiondata_.IsDefault()) {
    _impl_.conversiondata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.conversionData)
}

// optional uint32 conversionDelaySeconds = 20;
inline bool ContextInfo::_internal_has_conversiondelayseconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool ContextInfo::has_conversiondelayseconds() const {
  return _internal_has_conversiondelayseconds();
}
inline void ContextInfo::clear_conversiondelayseconds() {
  _impl_.conversiondelayseconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t ContextInfo::_internal_conversiondelayseconds() const {
  return _impl_.conversiondelayseconds_;
}
inline uint32_t ContextInfo::conversiondelayseconds() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.conversionDelaySeconds)
  return _internal_conversiondelayseconds();
}
inline void ContextInfo::_internal_set_conversiondelayseconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.conversiondelayseconds_ = value;
}
inline void ContextInfo::set_conversiondelayseconds(uint32_t value) {
  _internal_set_conversiondelayseconds(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.conversionDelaySeconds)
}

// optional uint32 forwardingScore = 21;
inline bool ContextInfo::_internal_has_forwardingscore() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool ContextInfo::has_forwardingscore() const {
  return _internal_has_forwardingscore();
}
inline void ContextInfo::clear_forwardingscore() {
  _impl_.forwardingscore_ = 0u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t ContextInfo::_internal_forwardingscore() const {
  return _impl_.forwardingscore_;
}
inline uint32_t ContextInfo::forwardingscore() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.forwardingScore)
  return _internal_forwardingscore();
}
inline void ContextInfo::_internal_set_forwardingscore(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.forwardingscore_ = value;
}
inline void ContextInfo::set_forwardingscore(uint32_t value) {
  _internal_set_forwardingscore(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.forwardingScore)
}

// optional bool isForwarded = 22;
inline bool ContextInfo::_internal_has_isforwarded() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool ContextInfo::has_isforwarded() const {
  return _internal_has_isforwarded();
}
inline void ContextInfo::clear_isforwarded() {
  _impl_.isforwarded_ = false;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline bool ContextInfo::_internal_isforwarded() const {
  return _impl_.isforwarded_;
}
inline bool ContextInfo::isforwarded() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.isForwarded)
  return _internal_isforwarded();
}
inline void ContextInfo::_internal_set_isforwarded(bool value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.isforwarded_ = value;
}
inline void ContextInfo::set_isforwarded(bool value) {
  _internal_set_isforwarded(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.isForwarded)
}

// optional .proto.ContextInfo.AdReplyInfo quotedAd = 23;
inline bool ContextInfo::_internal_has_quotedad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quotedad_ != nullptr);
  return value;
}
inline bool ContextInfo::has_quotedad() const {
  return _internal_has_quotedad();
}
inline void ContextInfo::clear_quotedad() {
  if (_impl_.quotedad_ != nullptr) _impl_.quotedad_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::_internal_quotedad() const {
  const ::proto::ContextInfo_AdReplyInfo* p = _impl_.quotedad_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo_AdReplyInfo&>(
      ::proto::_ContextInfo_AdReplyInfo_default_instance_);
}
inline const ::proto::ContextInfo_AdReplyInfo& ContextInfo::quotedad() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.quotedAd)
  return _internal_quotedad();
}
inline void ContextInfo::unsafe_arena_set_allocated_quotedad(
    ::proto::ContextInfo_AdReplyInfo* quotedad) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedad_);
  }
  _impl_.quotedad_ = quotedad;
  if (quotedad) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.quotedAd)
}
inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::release_quotedad() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_;
  _impl_.quotedad_ = 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 ::proto::ContextInfo_AdReplyInfo* ContextInfo::unsafe_arena_release_quotedad() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.quotedAd)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::ContextInfo_AdReplyInfo* temp = _impl_.quotedad_;
  _impl_.quotedad_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::_internal_mutable_quotedad() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.quotedad_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo_AdReplyInfo>(GetArenaForAllocation());
    _impl_.quotedad_ = p;
  }
  return _impl_.quotedad_;
}
inline ::proto::ContextInfo_AdReplyInfo* ContextInfo::mutable_quotedad() {
  ::proto::ContextInfo_AdReplyInfo* _msg = _internal_mutable_quotedad();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.quotedAd)
  return _msg;
}
inline void ContextInfo::set_allocated_quotedad(::proto::ContextInfo_AdReplyInfo* quotedad) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quotedad_;
  }
  if (quotedad) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedad);
    if (message_arena != submessage_arena) {
      quotedad = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quotedad, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.quotedad_ = quotedad;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.quotedAd)
}

// optional .proto.MessageKey placeholderKey = 24;
inline bool ContextInfo::_internal_has_placeholderkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.placeholderkey_ != nullptr);
  return value;
}
inline bool ContextInfo::has_placeholderkey() const {
  return _internal_has_placeholderkey();
}
inline void ContextInfo::clear_placeholderkey() {
  if (_impl_.placeholderkey_ != nullptr) _impl_.placeholderkey_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::MessageKey& ContextInfo::_internal_placeholderkey() const {
  const ::proto::MessageKey* p = _impl_.placeholderkey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& ContextInfo::placeholderkey() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.placeholderKey)
  return _internal_placeholderkey();
}
inline void ContextInfo::unsafe_arena_set_allocated_placeholderkey(
    ::proto::MessageKey* placeholderkey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.placeholderkey_);
  }
  _impl_.placeholderkey_ = placeholderkey;
  if (placeholderkey) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.placeholderKey)
}
inline ::proto::MessageKey* ContextInfo::release_placeholderkey() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::MessageKey* temp = _impl_.placeholderkey_;
  _impl_.placeholderkey_ = 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 ::proto::MessageKey* ContextInfo::unsafe_arena_release_placeholderkey() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.placeholderKey)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::MessageKey* temp = _impl_.placeholderkey_;
  _impl_.placeholderkey_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* ContextInfo::_internal_mutable_placeholderkey() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.placeholderkey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.placeholderkey_ = p;
  }
  return _impl_.placeholderkey_;
}
inline ::proto::MessageKey* ContextInfo::mutable_placeholderkey() {
  ::proto::MessageKey* _msg = _internal_mutable_placeholderkey();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.placeholderKey)
  return _msg;
}
inline void ContextInfo::set_allocated_placeholderkey(::proto::MessageKey* placeholderkey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.placeholderkey_;
  }
  if (placeholderkey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(placeholderkey);
    if (message_arena != submessage_arena) {
      placeholderkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, placeholderkey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.placeholderkey_ = placeholderkey;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.placeholderKey)
}

// optional uint32 expiration = 25;
inline bool ContextInfo::_internal_has_expiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool ContextInfo::has_expiration() const {
  return _internal_has_expiration();
}
inline void ContextInfo::clear_expiration() {
  _impl_.expiration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t ContextInfo::_internal_expiration() const {
  return _impl_.expiration_;
}
inline uint32_t ContextInfo::expiration() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.expiration)
  return _internal_expiration();
}
inline void ContextInfo::_internal_set_expiration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.expiration_ = value;
}
inline void ContextInfo::set_expiration(uint32_t value) {
  _internal_set_expiration(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.expiration)
}

// optional int64 ephemeralSettingTimestamp = 26;
inline bool ContextInfo::_internal_has_ephemeralsettingtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool ContextInfo::has_ephemeralsettingtimestamp() const {
  return _internal_has_ephemeralsettingtimestamp();
}
inline void ContextInfo::clear_ephemeralsettingtimestamp() {
  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int64_t ContextInfo::_internal_ephemeralsettingtimestamp() const {
  return _impl_.ephemeralsettingtimestamp_;
}
inline int64_t ContextInfo::ephemeralsettingtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSettingTimestamp)
  return _internal_ephemeralsettingtimestamp();
}
inline void ContextInfo::_internal_set_ephemeralsettingtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.ephemeralsettingtimestamp_ = value;
}
inline void ContextInfo::set_ephemeralsettingtimestamp(int64_t value) {
  _internal_set_ephemeralsettingtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSettingTimestamp)
}

// optional bytes ephemeralSharedSecret = 27;
inline bool ContextInfo::_internal_has_ephemeralsharedsecret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ContextInfo::has_ephemeralsharedsecret() const {
  return _internal_has_ephemeralsharedsecret();
}
inline void ContextInfo::clear_ephemeralsharedsecret() {
  _impl_.ephemeralsharedsecret_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& ContextInfo::ephemeralsharedsecret() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.ephemeralSharedSecret)
  return _internal_ephemeralsharedsecret();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_ephemeralsharedsecret(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.ephemeralsharedsecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.ephemeralSharedSecret)
}
inline std::string* ContextInfo::mutable_ephemeralsharedsecret() {
  std::string* _s = _internal_mutable_ephemeralsharedsecret();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.ephemeralSharedSecret)
  return _s;
}
inline const std::string& ContextInfo::_internal_ephemeralsharedsecret() const {
  return _impl_.ephemeralsharedsecret_.Get();
}
inline void ContextInfo::_internal_set_ephemeralsharedsecret(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.ephemeralsharedsecret_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_ephemeralsharedsecret() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.ephemeralsharedsecret_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_ephemeralsharedsecret() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.ephemeralSharedSecret)
  if (!_internal_has_ephemeralsharedsecret()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.ephemeralsharedsecret_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeralsharedsecret_.IsDefault()) {
    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_ephemeralsharedsecret(std::string* ephemeralsharedsecret) {
  if (ephemeralsharedsecret != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.ephemeralsharedsecret_.SetAllocated(ephemeralsharedsecret, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeralsharedsecret_.IsDefault()) {
    _impl_.ephemeralsharedsecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.ephemeralSharedSecret)
}

// optional .proto.ContextInfo.ExternalAdReplyInfo externalAdReply = 28;
inline bool ContextInfo::_internal_has_externaladreply() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.externaladreply_ != nullptr);
  return value;
}
inline bool ContextInfo::has_externaladreply() const {
  return _internal_has_externaladreply();
}
inline void ContextInfo::clear_externaladreply() {
  if (_impl_.externaladreply_ != nullptr) _impl_.externaladreply_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::_internal_externaladreply() const {
  const ::proto::ContextInfo_ExternalAdReplyInfo* p = _impl_.externaladreply_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo_ExternalAdReplyInfo&>(
      ::proto::_ContextInfo_ExternalAdReplyInfo_default_instance_);
}
inline const ::proto::ContextInfo_ExternalAdReplyInfo& ContextInfo::externaladreply() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.externalAdReply)
  return _internal_externaladreply();
}
inline void ContextInfo::unsafe_arena_set_allocated_externaladreply(
    ::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externaladreply_);
  }
  _impl_.externaladreply_ = externaladreply;
  if (externaladreply) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.externalAdReply)
}
inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::release_externaladreply() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_;
  _impl_.externaladreply_ = 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 ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::unsafe_arena_release_externaladreply() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.externalAdReply)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo_ExternalAdReplyInfo* temp = _impl_.externaladreply_;
  _impl_.externaladreply_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::_internal_mutable_externaladreply() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.externaladreply_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo_ExternalAdReplyInfo>(GetArenaForAllocation());
    _impl_.externaladreply_ = p;
  }
  return _impl_.externaladreply_;
}
inline ::proto::ContextInfo_ExternalAdReplyInfo* ContextInfo::mutable_externaladreply() {
  ::proto::ContextInfo_ExternalAdReplyInfo* _msg = _internal_mutable_externaladreply();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.externalAdReply)
  return _msg;
}
inline void ContextInfo::set_allocated_externaladreply(::proto::ContextInfo_ExternalAdReplyInfo* externaladreply) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.externaladreply_;
  }
  if (externaladreply) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externaladreply);
    if (message_arena != submessage_arena) {
      externaladreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, externaladreply, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.externaladreply_ = externaladreply;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.externalAdReply)
}

// optional string entryPointConversionSource = 29;
inline bool ContextInfo::_internal_has_entrypointconversionsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool ContextInfo::has_entrypointconversionsource() const {
  return _internal_has_entrypointconversionsource();
}
inline void ContextInfo::clear_entrypointconversionsource() {
  _impl_.entrypointconversionsource_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& ContextInfo::entrypointconversionsource() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionSource)
  return _internal_entrypointconversionsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_entrypointconversionsource(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.entrypointconversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionSource)
}
inline std::string* ContextInfo::mutable_entrypointconversionsource() {
  std::string* _s = _internal_mutable_entrypointconversionsource();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionSource)
  return _s;
}
inline const std::string& ContextInfo::_internal_entrypointconversionsource() const {
  return _impl_.entrypointconversionsource_.Get();
}
inline void ContextInfo::_internal_set_entrypointconversionsource(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.entrypointconversionsource_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_entrypointconversionsource() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.entrypointconversionsource_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_entrypointconversionsource() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionSource)
  if (!_internal_has_entrypointconversionsource()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.entrypointconversionsource_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entrypointconversionsource_.IsDefault()) {
    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_entrypointconversionsource(std::string* entrypointconversionsource) {
  if (entrypointconversionsource != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.entrypointconversionsource_.SetAllocated(entrypointconversionsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entrypointconversionsource_.IsDefault()) {
    _impl_.entrypointconversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionSource)
}

// optional string entryPointConversionApp = 30;
inline bool ContextInfo::_internal_has_entrypointconversionapp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool ContextInfo::has_entrypointconversionapp() const {
  return _internal_has_entrypointconversionapp();
}
inline void ContextInfo::clear_entrypointconversionapp() {
  _impl_.entrypointconversionapp_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& ContextInfo::entrypointconversionapp() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionApp)
  return _internal_entrypointconversionapp();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_entrypointconversionapp(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.entrypointconversionapp_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionApp)
}
inline std::string* ContextInfo::mutable_entrypointconversionapp() {
  std::string* _s = _internal_mutable_entrypointconversionapp();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.entryPointConversionApp)
  return _s;
}
inline const std::string& ContextInfo::_internal_entrypointconversionapp() const {
  return _impl_.entrypointconversionapp_.Get();
}
inline void ContextInfo::_internal_set_entrypointconversionapp(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.entrypointconversionapp_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_entrypointconversionapp() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.entrypointconversionapp_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_entrypointconversionapp() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.entryPointConversionApp)
  if (!_internal_has_entrypointconversionapp()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.entrypointconversionapp_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entrypointconversionapp_.IsDefault()) {
    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_entrypointconversionapp(std::string* entrypointconversionapp) {
  if (entrypointconversionapp != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.entrypointconversionapp_.SetAllocated(entrypointconversionapp, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.entrypointconversionapp_.IsDefault()) {
    _impl_.entrypointconversionapp_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.entryPointConversionApp)
}

// optional uint32 entryPointConversionDelaySeconds = 31;
inline bool ContextInfo::_internal_has_entrypointconversiondelayseconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool ContextInfo::has_entrypointconversiondelayseconds() const {
  return _internal_has_entrypointconversiondelayseconds();
}
inline void ContextInfo::clear_entrypointconversiondelayseconds() {
  _impl_.entrypointconversiondelayseconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint32_t ContextInfo::_internal_entrypointconversiondelayseconds() const {
  return _impl_.entrypointconversiondelayseconds_;
}
inline uint32_t ContextInfo::entrypointconversiondelayseconds() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.entryPointConversionDelaySeconds)
  return _internal_entrypointconversiondelayseconds();
}
inline void ContextInfo::_internal_set_entrypointconversiondelayseconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.entrypointconversiondelayseconds_ = value;
}
inline void ContextInfo::set_entrypointconversiondelayseconds(uint32_t value) {
  _internal_set_entrypointconversiondelayseconds(value);
  // @@protoc_insertion_point(field_set:proto.ContextInfo.entryPointConversionDelaySeconds)
}

// optional .proto.DisappearingMode disappearingMode = 32;
inline bool ContextInfo::_internal_has_disappearingmode() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
  return value;
}
inline bool ContextInfo::has_disappearingmode() const {
  return _internal_has_disappearingmode();
}
inline void ContextInfo::clear_disappearingmode() {
  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::proto::DisappearingMode& ContextInfo::_internal_disappearingmode() const {
  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
      ::proto::_DisappearingMode_default_instance_);
}
inline const ::proto::DisappearingMode& ContextInfo::disappearingmode() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.disappearingMode)
  return _internal_disappearingmode();
}
inline void ContextInfo::unsafe_arena_set_allocated_disappearingmode(
    ::proto::DisappearingMode* disappearingmode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
  }
  _impl_.disappearingmode_ = disappearingmode;
  if (disappearingmode) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.disappearingMode)
}
inline ::proto::DisappearingMode* ContextInfo::release_disappearingmode() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = 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 ::proto::DisappearingMode* ContextInfo::unsafe_arena_release_disappearingmode() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.disappearingMode)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = nullptr;
  return temp;
}
inline ::proto::DisappearingMode* ContextInfo::_internal_mutable_disappearingmode() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.disappearingmode_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
    _impl_.disappearingmode_ = p;
  }
  return _impl_.disappearingmode_;
}
inline ::proto::DisappearingMode* ContextInfo::mutable_disappearingmode() {
  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.disappearingMode)
  return _msg;
}
inline void ContextInfo::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.disappearingmode_;
  }
  if (disappearingmode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
    if (message_arena != submessage_arena) {
      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, disappearingmode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.disappearingmode_ = disappearingmode;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.disappearingMode)
}

// optional .proto.ActionLink actionLink = 33;
inline bool ContextInfo::_internal_has_actionlink() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.actionlink_ != nullptr);
  return value;
}
inline bool ContextInfo::has_actionlink() const {
  return _internal_has_actionlink();
}
inline void ContextInfo::clear_actionlink() {
  if (_impl_.actionlink_ != nullptr) _impl_.actionlink_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::proto::ActionLink& ContextInfo::_internal_actionlink() const {
  const ::proto::ActionLink* p = _impl_.actionlink_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ActionLink&>(
      ::proto::_ActionLink_default_instance_);
}
inline const ::proto::ActionLink& ContextInfo::actionlink() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.actionLink)
  return _internal_actionlink();
}
inline void ContextInfo::unsafe_arena_set_allocated_actionlink(
    ::proto::ActionLink* actionlink) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.actionlink_);
  }
  _impl_.actionlink_ = actionlink;
  if (actionlink) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.ContextInfo.actionLink)
}
inline ::proto::ActionLink* ContextInfo::release_actionlink() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::ActionLink* temp = _impl_.actionlink_;
  _impl_.actionlink_ = 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 ::proto::ActionLink* ContextInfo::unsafe_arena_release_actionlink() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.actionLink)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::ActionLink* temp = _impl_.actionlink_;
  _impl_.actionlink_ = nullptr;
  return temp;
}
inline ::proto::ActionLink* ContextInfo::_internal_mutable_actionlink() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.actionlink_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ActionLink>(GetArenaForAllocation());
    _impl_.actionlink_ = p;
  }
  return _impl_.actionlink_;
}
inline ::proto::ActionLink* ContextInfo::mutable_actionlink() {
  ::proto::ActionLink* _msg = _internal_mutable_actionlink();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.actionLink)
  return _msg;
}
inline void ContextInfo::set_allocated_actionlink(::proto::ActionLink* actionlink) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.actionlink_;
  }
  if (actionlink) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(actionlink);
    if (message_arena != submessage_arena) {
      actionlink = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, actionlink, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.actionlink_ = actionlink;
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.actionLink)
}

// optional string groupSubject = 34;
inline bool ContextInfo::_internal_has_groupsubject() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool ContextInfo::has_groupsubject() const {
  return _internal_has_groupsubject();
}
inline void ContextInfo::clear_groupsubject() {
  _impl_.groupsubject_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& ContextInfo::groupsubject() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.groupSubject)
  return _internal_groupsubject();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_groupsubject(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.groupsubject_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.groupSubject)
}
inline std::string* ContextInfo::mutable_groupsubject() {
  std::string* _s = _internal_mutable_groupsubject();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.groupSubject)
  return _s;
}
inline const std::string& ContextInfo::_internal_groupsubject() const {
  return _impl_.groupsubject_.Get();
}
inline void ContextInfo::_internal_set_groupsubject(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.groupsubject_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_groupsubject() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.groupsubject_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_groupsubject() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.groupSubject)
  if (!_internal_has_groupsubject()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.groupsubject_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupsubject_.IsDefault()) {
    _impl_.groupsubject_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_groupsubject(std::string* groupsubject) {
  if (groupsubject != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.groupsubject_.SetAllocated(groupsubject, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupsubject_.IsDefault()) {
    _impl_.groupsubject_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.groupSubject)
}

// optional string parentGroupJid = 35;
inline bool ContextInfo::_internal_has_parentgroupjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool ContextInfo::has_parentgroupjid() const {
  return _internal_has_parentgroupjid();
}
inline void ContextInfo::clear_parentgroupjid() {
  _impl_.parentgroupjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& ContextInfo::parentgroupjid() const {
  // @@protoc_insertion_point(field_get:proto.ContextInfo.parentGroupJid)
  return _internal_parentgroupjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ContextInfo::set_parentgroupjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.parentgroupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ContextInfo.parentGroupJid)
}
inline std::string* ContextInfo::mutable_parentgroupjid() {
  std::string* _s = _internal_mutable_parentgroupjid();
  // @@protoc_insertion_point(field_mutable:proto.ContextInfo.parentGroupJid)
  return _s;
}
inline const std::string& ContextInfo::_internal_parentgroupjid() const {
  return _impl_.parentgroupjid_.Get();
}
inline void ContextInfo::_internal_set_parentgroupjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.parentgroupjid_.Set(value, GetArenaForAllocation());
}
inline std::string* ContextInfo::_internal_mutable_parentgroupjid() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.parentgroupjid_.Mutable(GetArenaForAllocation());
}
inline std::string* ContextInfo::release_parentgroupjid() {
  // @@protoc_insertion_point(field_release:proto.ContextInfo.parentGroupJid)
  if (!_internal_has_parentgroupjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.parentgroupjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentgroupjid_.IsDefault()) {
    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ContextInfo::set_allocated_parentgroupjid(std::string* parentgroupjid) {
  if (parentgroupjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.parentgroupjid_.SetAllocated(parentgroupjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentgroupjid_.IsDefault()) {
    _impl_.parentgroupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ContextInfo.parentGroupJid)
}

// -------------------------------------------------------------------

// Conversation

// required string id = 1;
inline bool Conversation::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Conversation::has_id() const {
  return _internal_has_id();
}
inline void Conversation::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Conversation::id() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.id)
}
inline std::string* Conversation::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.id)
  return _s;
}
inline const std::string& Conversation::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Conversation::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_id() {
  // @@protoc_insertion_point(field_release:proto.Conversation.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.id)
}

// repeated .proto.HistorySyncMsg messages = 2;
inline int Conversation::_internal_messages_size() const {
  return _impl_.messages_.size();
}
inline int Conversation::messages_size() const {
  return _internal_messages_size();
}
inline void Conversation::clear_messages() {
  _impl_.messages_.Clear();
}
inline ::proto::HistorySyncMsg* Conversation::mutable_messages(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Conversation.messages)
  return _impl_.messages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >*
Conversation::mutable_messages() {
  // @@protoc_insertion_point(field_mutable_list:proto.Conversation.messages)
  return &_impl_.messages_;
}
inline const ::proto::HistorySyncMsg& Conversation::_internal_messages(int index) const {
  return _impl_.messages_.Get(index);
}
inline const ::proto::HistorySyncMsg& Conversation::messages(int index) const {
  // @@protoc_insertion_point(field_get:proto.Conversation.messages)
  return _internal_messages(index);
}
inline ::proto::HistorySyncMsg* Conversation::_internal_add_messages() {
  return _impl_.messages_.Add();
}
inline ::proto::HistorySyncMsg* Conversation::add_messages() {
  ::proto::HistorySyncMsg* _add = _internal_add_messages();
  // @@protoc_insertion_point(field_add:proto.Conversation.messages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HistorySyncMsg >&
Conversation::messages() const {
  // @@protoc_insertion_point(field_list:proto.Conversation.messages)
  return _impl_.messages_;
}

// optional string newJid = 3;
inline bool Conversation::_internal_has_newjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Conversation::has_newjid() const {
  return _internal_has_newjid();
}
inline void Conversation::clear_newjid() {
  _impl_.newjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Conversation::newjid() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.newJid)
  return _internal_newjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_newjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.newjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.newJid)
}
inline std::string* Conversation::mutable_newjid() {
  std::string* _s = _internal_mutable_newjid();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.newJid)
  return _s;
}
inline const std::string& Conversation::_internal_newjid() const {
  return _impl_.newjid_.Get();
}
inline void Conversation::_internal_set_newjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.newjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_newjid() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.newjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_newjid() {
  // @@protoc_insertion_point(field_release:proto.Conversation.newJid)
  if (!_internal_has_newjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.newjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.newjid_.IsDefault()) {
    _impl_.newjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_newjid(std::string* newjid) {
  if (newjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.newjid_.SetAllocated(newjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.newjid_.IsDefault()) {
    _impl_.newjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.newJid)
}

// optional string oldJid = 4;
inline bool Conversation::_internal_has_oldjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Conversation::has_oldjid() const {
  return _internal_has_oldjid();
}
inline void Conversation::clear_oldjid() {
  _impl_.oldjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Conversation::oldjid() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.oldJid)
  return _internal_oldjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_oldjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.oldjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.oldJid)
}
inline std::string* Conversation::mutable_oldjid() {
  std::string* _s = _internal_mutable_oldjid();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.oldJid)
  return _s;
}
inline const std::string& Conversation::_internal_oldjid() const {
  return _impl_.oldjid_.Get();
}
inline void Conversation::_internal_set_oldjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.oldjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_oldjid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.oldjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_oldjid() {
  // @@protoc_insertion_point(field_release:proto.Conversation.oldJid)
  if (!_internal_has_oldjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.oldjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.oldjid_.IsDefault()) {
    _impl_.oldjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_oldjid(std::string* oldjid) {
  if (oldjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.oldjid_.SetAllocated(oldjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.oldjid_.IsDefault()) {
    _impl_.oldjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.oldJid)
}

// optional uint64 lastMsgTimestamp = 5;
inline bool Conversation::_internal_has_lastmsgtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Conversation::has_lastmsgtimestamp() const {
  return _internal_has_lastmsgtimestamp();
}
inline void Conversation::clear_lastmsgtimestamp() {
  _impl_.lastmsgtimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t Conversation::_internal_lastmsgtimestamp() const {
  return _impl_.lastmsgtimestamp_;
}
inline uint64_t Conversation::lastmsgtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.lastMsgTimestamp)
  return _internal_lastmsgtimestamp();
}
inline void Conversation::_internal_set_lastmsgtimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.lastmsgtimestamp_ = value;
}
inline void Conversation::set_lastmsgtimestamp(uint64_t value) {
  _internal_set_lastmsgtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.lastMsgTimestamp)
}

// optional uint32 unreadCount = 6;
inline bool Conversation::_internal_has_unreadcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Conversation::has_unreadcount() const {
  return _internal_has_unreadcount();
}
inline void Conversation::clear_unreadcount() {
  _impl_.unreadcount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t Conversation::_internal_unreadcount() const {
  return _impl_.unreadcount_;
}
inline uint32_t Conversation::unreadcount() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.unreadCount)
  return _internal_unreadcount();
}
inline void Conversation::_internal_set_unreadcount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.unreadcount_ = value;
}
inline void Conversation::set_unreadcount(uint32_t value) {
  _internal_set_unreadcount(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.unreadCount)
}

// optional bool readOnly = 7;
inline bool Conversation::_internal_has_readonly() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Conversation::has_readonly() const {
  return _internal_has_readonly();
}
inline void Conversation::clear_readonly() {
  _impl_.readonly_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool Conversation::_internal_readonly() const {
  return _impl_.readonly_;
}
inline bool Conversation::readonly() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.readOnly)
  return _internal_readonly();
}
inline void Conversation::_internal_set_readonly(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.readonly_ = value;
}
inline void Conversation::set_readonly(bool value) {
  _internal_set_readonly(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.readOnly)
}

// optional bool endOfHistoryTransfer = 8;
inline bool Conversation::_internal_has_endofhistorytransfer() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Conversation::has_endofhistorytransfer() const {
  return _internal_has_endofhistorytransfer();
}
inline void Conversation::clear_endofhistorytransfer() {
  _impl_.endofhistorytransfer_ = false;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline bool Conversation::_internal_endofhistorytransfer() const {
  return _impl_.endofhistorytransfer_;
}
inline bool Conversation::endofhistorytransfer() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransfer)
  return _internal_endofhistorytransfer();
}
inline void Conversation::_internal_set_endofhistorytransfer(bool value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.endofhistorytransfer_ = value;
}
inline void Conversation::set_endofhistorytransfer(bool value) {
  _internal_set_endofhistorytransfer(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransfer)
}

// optional uint32 ephemeralExpiration = 9;
inline bool Conversation::_internal_has_ephemeralexpiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Conversation::has_ephemeralexpiration() const {
  return _internal_has_ephemeralexpiration();
}
inline void Conversation::clear_ephemeralexpiration() {
  _impl_.ephemeralexpiration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t Conversation::_internal_ephemeralexpiration() const {
  return _impl_.ephemeralexpiration_;
}
inline uint32_t Conversation::ephemeralexpiration() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralExpiration)
  return _internal_ephemeralexpiration();
}
inline void Conversation::_internal_set_ephemeralexpiration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.ephemeralexpiration_ = value;
}
inline void Conversation::set_ephemeralexpiration(uint32_t value) {
  _internal_set_ephemeralexpiration(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralExpiration)
}

// optional int64 ephemeralSettingTimestamp = 10;
inline bool Conversation::_internal_has_ephemeralsettingtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Conversation::has_ephemeralsettingtimestamp() const {
  return _internal_has_ephemeralsettingtimestamp();
}
inline void Conversation::clear_ephemeralsettingtimestamp() {
  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int64_t Conversation::_internal_ephemeralsettingtimestamp() const {
  return _impl_.ephemeralsettingtimestamp_;
}
inline int64_t Conversation::ephemeralsettingtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.ephemeralSettingTimestamp)
  return _internal_ephemeralsettingtimestamp();
}
inline void Conversation::_internal_set_ephemeralsettingtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.ephemeralsettingtimestamp_ = value;
}
inline void Conversation::set_ephemeralsettingtimestamp(int64_t value) {
  _internal_set_ephemeralsettingtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.ephemeralSettingTimestamp)
}

// optional .proto.Conversation.EndOfHistoryTransferType endOfHistoryTransferType = 11;
inline bool Conversation::_internal_has_endofhistorytransfertype() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Conversation::has_endofhistorytransfertype() const {
  return _internal_has_endofhistorytransfertype();
}
inline void Conversation::clear_endofhistorytransfertype() {
  _impl_.endofhistorytransfertype_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::proto::Conversation_EndOfHistoryTransferType Conversation::_internal_endofhistorytransfertype() const {
  return static_cast< ::proto::Conversation_EndOfHistoryTransferType >(_impl_.endofhistorytransfertype_);
}
inline ::proto::Conversation_EndOfHistoryTransferType Conversation::endofhistorytransfertype() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.endOfHistoryTransferType)
  return _internal_endofhistorytransfertype();
}
inline void Conversation::_internal_set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) {
  assert(::proto::Conversation_EndOfHistoryTransferType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.endofhistorytransfertype_ = value;
}
inline void Conversation::set_endofhistorytransfertype(::proto::Conversation_EndOfHistoryTransferType value) {
  _internal_set_endofhistorytransfertype(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.endOfHistoryTransferType)
}

// optional uint64 conversationTimestamp = 12;
inline bool Conversation::_internal_has_conversationtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool Conversation::has_conversationtimestamp() const {
  return _internal_has_conversationtimestamp();
}
inline void Conversation::clear_conversationtimestamp() {
  _impl_.conversationtimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline uint64_t Conversation::_internal_conversationtimestamp() const {
  return _impl_.conversationtimestamp_;
}
inline uint64_t Conversation::conversationtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.conversationTimestamp)
  return _internal_conversationtimestamp();
}
inline void Conversation::_internal_set_conversationtimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.conversationtimestamp_ = value;
}
inline void Conversation::set_conversationtimestamp(uint64_t value) {
  _internal_set_conversationtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.conversationTimestamp)
}

// optional string name = 13;
inline bool Conversation::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Conversation::has_name() const {
  return _internal_has_name();
}
inline void Conversation::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Conversation::name() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.name)
}
inline std::string* Conversation::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.name)
  return _s;
}
inline const std::string& Conversation::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Conversation::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_name() {
  // @@protoc_insertion_point(field_release:proto.Conversation.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  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 Conversation::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _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:proto.Conversation.name)
}

// optional string pHash = 14;
inline bool Conversation::_internal_has_phash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Conversation::has_phash() const {
  return _internal_has_phash();
}
inline void Conversation::clear_phash() {
  _impl_.phash_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Conversation::phash() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.pHash)
  return _internal_phash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_phash(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.phash_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.pHash)
}
inline std::string* Conversation::mutable_phash() {
  std::string* _s = _internal_mutable_phash();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.pHash)
  return _s;
}
inline const std::string& Conversation::_internal_phash() const {
  return _impl_.phash_.Get();
}
inline void Conversation::_internal_set_phash(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.phash_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_phash() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.phash_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_phash() {
  // @@protoc_insertion_point(field_release:proto.Conversation.pHash)
  if (!_internal_has_phash()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.phash_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phash_.IsDefault()) {
    _impl_.phash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_phash(std::string* phash) {
  if (phash != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.phash_.SetAllocated(phash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phash_.IsDefault()) {
    _impl_.phash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pHash)
}

// optional bool notSpam = 15;
inline bool Conversation::_internal_has_notspam() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool Conversation::has_notspam() const {
  return _internal_has_notspam();
}
inline void Conversation::clear_notspam() {
  _impl_.notspam_ = false;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline bool Conversation::_internal_notspam() const {
  return _impl_.notspam_;
}
inline bool Conversation::notspam() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.notSpam)
  return _internal_notspam();
}
inline void Conversation::_internal_set_notspam(bool value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.notspam_ = value;
}
inline void Conversation::set_notspam(bool value) {
  _internal_set_notspam(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.notSpam)
}

// optional bool archived = 16;
inline bool Conversation::_internal_has_archived() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool Conversation::has_archived() const {
  return _internal_has_archived();
}
inline void Conversation::clear_archived() {
  _impl_.archived_ = false;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool Conversation::_internal_archived() const {
  return _impl_.archived_;
}
inline bool Conversation::archived() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.archived)
  return _internal_archived();
}
inline void Conversation::_internal_set_archived(bool value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.archived_ = value;
}
inline void Conversation::set_archived(bool value) {
  _internal_set_archived(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.archived)
}

// optional .proto.DisappearingMode disappearingMode = 17;
inline bool Conversation::_internal_has_disappearingmode() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
  return value;
}
inline bool Conversation::has_disappearingmode() const {
  return _internal_has_disappearingmode();
}
inline void Conversation::clear_disappearingmode() {
  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::DisappearingMode& Conversation::_internal_disappearingmode() const {
  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
      ::proto::_DisappearingMode_default_instance_);
}
inline const ::proto::DisappearingMode& Conversation::disappearingmode() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.disappearingMode)
  return _internal_disappearingmode();
}
inline void Conversation::unsafe_arena_set_allocated_disappearingmode(
    ::proto::DisappearingMode* disappearingmode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
  }
  _impl_.disappearingmode_ = disappearingmode;
  if (disappearingmode) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.disappearingMode)
}
inline ::proto::DisappearingMode* Conversation::release_disappearingmode() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = 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 ::proto::DisappearingMode* Conversation::unsafe_arena_release_disappearingmode() {
  // @@protoc_insertion_point(field_release:proto.Conversation.disappearingMode)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = nullptr;
  return temp;
}
inline ::proto::DisappearingMode* Conversation::_internal_mutable_disappearingmode() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.disappearingmode_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
    _impl_.disappearingmode_ = p;
  }
  return _impl_.disappearingmode_;
}
inline ::proto::DisappearingMode* Conversation::mutable_disappearingmode() {
  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.disappearingMode)
  return _msg;
}
inline void Conversation::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.disappearingmode_;
  }
  if (disappearingmode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
    if (message_arena != submessage_arena) {
      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, disappearingmode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.disappearingmode_ = disappearingmode;
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.disappearingMode)
}

// optional uint32 unreadMentionCount = 18;
inline bool Conversation::_internal_has_unreadmentioncount() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool Conversation::has_unreadmentioncount() const {
  return _internal_has_unreadmentioncount();
}
inline void Conversation::clear_unreadmentioncount() {
  _impl_.unreadmentioncount_ = 0u;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline uint32_t Conversation::_internal_unreadmentioncount() const {
  return _impl_.unreadmentioncount_;
}
inline uint32_t Conversation::unreadmentioncount() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.unreadMentionCount)
  return _internal_unreadmentioncount();
}
inline void Conversation::_internal_set_unreadmentioncount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.unreadmentioncount_ = value;
}
inline void Conversation::set_unreadmentioncount(uint32_t value) {
  _internal_set_unreadmentioncount(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.unreadMentionCount)
}

// optional bool markedAsUnread = 19;
inline bool Conversation::_internal_has_markedasunread() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool Conversation::has_markedasunread() const {
  return _internal_has_markedasunread();
}
inline void Conversation::clear_markedasunread() {
  _impl_.markedasunread_ = false;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline bool Conversation::_internal_markedasunread() const {
  return _impl_.markedasunread_;
}
inline bool Conversation::markedasunread() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.markedAsUnread)
  return _internal_markedasunread();
}
inline void Conversation::_internal_set_markedasunread(bool value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.markedasunread_ = value;
}
inline void Conversation::set_markedasunread(bool value) {
  _internal_set_markedasunread(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.markedAsUnread)
}

// repeated .proto.GroupParticipant participant = 20;
inline int Conversation::_internal_participant_size() const {
  return _impl_.participant_.size();
}
inline int Conversation::participant_size() const {
  return _internal_participant_size();
}
inline void Conversation::clear_participant() {
  _impl_.participant_.Clear();
}
inline ::proto::GroupParticipant* Conversation::mutable_participant(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Conversation.participant)
  return _impl_.participant_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >*
Conversation::mutable_participant() {
  // @@protoc_insertion_point(field_mutable_list:proto.Conversation.participant)
  return &_impl_.participant_;
}
inline const ::proto::GroupParticipant& Conversation::_internal_participant(int index) const {
  return _impl_.participant_.Get(index);
}
inline const ::proto::GroupParticipant& Conversation::participant(int index) const {
  // @@protoc_insertion_point(field_get:proto.Conversation.participant)
  return _internal_participant(index);
}
inline ::proto::GroupParticipant* Conversation::_internal_add_participant() {
  return _impl_.participant_.Add();
}
inline ::proto::GroupParticipant* Conversation::add_participant() {
  ::proto::GroupParticipant* _add = _internal_add_participant();
  // @@protoc_insertion_point(field_add:proto.Conversation.participant)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::GroupParticipant >&
Conversation::participant() const {
  // @@protoc_insertion_point(field_list:proto.Conversation.participant)
  return _impl_.participant_;
}

// optional bytes tcToken = 21;
inline bool Conversation::_internal_has_tctoken() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Conversation::has_tctoken() const {
  return _internal_has_tctoken();
}
inline void Conversation::clear_tctoken() {
  _impl_.tctoken_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Conversation::tctoken() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.tcToken)
  return _internal_tctoken();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_tctoken(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.tctoken_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.tcToken)
}
inline std::string* Conversation::mutable_tctoken() {
  std::string* _s = _internal_mutable_tctoken();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.tcToken)
  return _s;
}
inline const std::string& Conversation::_internal_tctoken() const {
  return _impl_.tctoken_.Get();
}
inline void Conversation::_internal_set_tctoken(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.tctoken_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_tctoken() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.tctoken_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_tctoken() {
  // @@protoc_insertion_point(field_release:proto.Conversation.tcToken)
  if (!_internal_has_tctoken()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.tctoken_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tctoken_.IsDefault()) {
    _impl_.tctoken_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_tctoken(std::string* tctoken) {
  if (tctoken != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.tctoken_.SetAllocated(tctoken, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.tctoken_.IsDefault()) {
    _impl_.tctoken_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.tcToken)
}

// optional uint64 tcTokenTimestamp = 22;
inline bool Conversation::_internal_has_tctokentimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool Conversation::has_tctokentimestamp() const {
  return _internal_has_tctokentimestamp();
}
inline void Conversation::clear_tctokentimestamp() {
  _impl_.tctokentimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline uint64_t Conversation::_internal_tctokentimestamp() const {
  return _impl_.tctokentimestamp_;
}
inline uint64_t Conversation::tctokentimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenTimestamp)
  return _internal_tctokentimestamp();
}
inline void Conversation::_internal_set_tctokentimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.tctokentimestamp_ = value;
}
inline void Conversation::set_tctokentimestamp(uint64_t value) {
  _internal_set_tctokentimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenTimestamp)
}

// optional bytes contactPrimaryIdentityKey = 23;
inline bool Conversation::_internal_has_contactprimaryidentitykey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Conversation::has_contactprimaryidentitykey() const {
  return _internal_has_contactprimaryidentitykey();
}
inline void Conversation::clear_contactprimaryidentitykey() {
  _impl_.contactprimaryidentitykey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Conversation::contactprimaryidentitykey() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.contactPrimaryIdentityKey)
  return _internal_contactprimaryidentitykey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_contactprimaryidentitykey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.contactprimaryidentitykey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.contactPrimaryIdentityKey)
}
inline std::string* Conversation::mutable_contactprimaryidentitykey() {
  std::string* _s = _internal_mutable_contactprimaryidentitykey();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.contactPrimaryIdentityKey)
  return _s;
}
inline const std::string& Conversation::_internal_contactprimaryidentitykey() const {
  return _impl_.contactprimaryidentitykey_.Get();
}
inline void Conversation::_internal_set_contactprimaryidentitykey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.contactprimaryidentitykey_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_contactprimaryidentitykey() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.contactprimaryidentitykey_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_contactprimaryidentitykey() {
  // @@protoc_insertion_point(field_release:proto.Conversation.contactPrimaryIdentityKey)
  if (!_internal_has_contactprimaryidentitykey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.contactprimaryidentitykey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contactprimaryidentitykey_.IsDefault()) {
    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_contactprimaryidentitykey(std::string* contactprimaryidentitykey) {
  if (contactprimaryidentitykey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.contactprimaryidentitykey_.SetAllocated(contactprimaryidentitykey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contactprimaryidentitykey_.IsDefault()) {
    _impl_.contactprimaryidentitykey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.contactPrimaryIdentityKey)
}

// optional uint32 pinned = 24;
inline bool Conversation::_internal_has_pinned() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool Conversation::has_pinned() const {
  return _internal_has_pinned();
}
inline void Conversation::clear_pinned() {
  _impl_.pinned_ = 0u;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline uint32_t Conversation::_internal_pinned() const {
  return _impl_.pinned_;
}
inline uint32_t Conversation::pinned() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.pinned)
  return _internal_pinned();
}
inline void Conversation::_internal_set_pinned(uint32_t value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.pinned_ = value;
}
inline void Conversation::set_pinned(uint32_t value) {
  _internal_set_pinned(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.pinned)
}

// optional uint64 muteEndTime = 25;
inline bool Conversation::_internal_has_muteendtime() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool Conversation::has_muteendtime() const {
  return _internal_has_muteendtime();
}
inline void Conversation::clear_muteendtime() {
  _impl_.muteendtime_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline uint64_t Conversation::_internal_muteendtime() const {
  return _impl_.muteendtime_;
}
inline uint64_t Conversation::muteendtime() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.muteEndTime)
  return _internal_muteendtime();
}
inline void Conversation::_internal_set_muteendtime(uint64_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.muteendtime_ = value;
}
inline void Conversation::set_muteendtime(uint64_t value) {
  _internal_set_muteendtime(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.muteEndTime)
}

// optional .proto.WallpaperSettings wallpaper = 26;
inline bool Conversation::_internal_has_wallpaper() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.wallpaper_ != nullptr);
  return value;
}
inline bool Conversation::has_wallpaper() const {
  return _internal_has_wallpaper();
}
inline void Conversation::clear_wallpaper() {
  if (_impl_.wallpaper_ != nullptr) _impl_.wallpaper_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::WallpaperSettings& Conversation::_internal_wallpaper() const {
  const ::proto::WallpaperSettings* p = _impl_.wallpaper_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
      ::proto::_WallpaperSettings_default_instance_);
}
inline const ::proto::WallpaperSettings& Conversation::wallpaper() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.wallpaper)
  return _internal_wallpaper();
}
inline void Conversation::unsafe_arena_set_allocated_wallpaper(
    ::proto::WallpaperSettings* wallpaper) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.wallpaper_);
  }
  _impl_.wallpaper_ = wallpaper;
  if (wallpaper) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Conversation.wallpaper)
}
inline ::proto::WallpaperSettings* Conversation::release_wallpaper() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::WallpaperSettings* temp = _impl_.wallpaper_;
  _impl_.wallpaper_ = 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 ::proto::WallpaperSettings* Conversation::unsafe_arena_release_wallpaper() {
  // @@protoc_insertion_point(field_release:proto.Conversation.wallpaper)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::WallpaperSettings* temp = _impl_.wallpaper_;
  _impl_.wallpaper_ = nullptr;
  return temp;
}
inline ::proto::WallpaperSettings* Conversation::_internal_mutable_wallpaper() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.wallpaper_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
    _impl_.wallpaper_ = p;
  }
  return _impl_.wallpaper_;
}
inline ::proto::WallpaperSettings* Conversation::mutable_wallpaper() {
  ::proto::WallpaperSettings* _msg = _internal_mutable_wallpaper();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.wallpaper)
  return _msg;
}
inline void Conversation::set_allocated_wallpaper(::proto::WallpaperSettings* wallpaper) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.wallpaper_;
  }
  if (wallpaper) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(wallpaper);
    if (message_arena != submessage_arena) {
      wallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, wallpaper, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.wallpaper_ = wallpaper;
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.wallpaper)
}

// optional .proto.MediaVisibility mediaVisibility = 27;
inline bool Conversation::_internal_has_mediavisibility() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool Conversation::has_mediavisibility() const {
  return _internal_has_mediavisibility();
}
inline void Conversation::clear_mediavisibility() {
  _impl_.mediavisibility_ = 0;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline ::proto::MediaVisibility Conversation::_internal_mediavisibility() const {
  return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_);
}
inline ::proto::MediaVisibility Conversation::mediavisibility() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.mediaVisibility)
  return _internal_mediavisibility();
}
inline void Conversation::_internal_set_mediavisibility(::proto::MediaVisibility value) {
  assert(::proto::MediaVisibility_IsValid(value));
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.mediavisibility_ = value;
}
inline void Conversation::set_mediavisibility(::proto::MediaVisibility value) {
  _internal_set_mediavisibility(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.mediaVisibility)
}

// optional uint64 tcTokenSenderTimestamp = 28;
inline bool Conversation::_internal_has_tctokensendertimestamp() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool Conversation::has_tctokensendertimestamp() const {
  return _internal_has_tctokensendertimestamp();
}
inline void Conversation::clear_tctokensendertimestamp() {
  _impl_.tctokensendertimestamp_ = uint64_t{0u};
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline uint64_t Conversation::_internal_tctokensendertimestamp() const {
  return _impl_.tctokensendertimestamp_;
}
inline uint64_t Conversation::tctokensendertimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.tcTokenSenderTimestamp)
  return _internal_tctokensendertimestamp();
}
inline void Conversation::_internal_set_tctokensendertimestamp(uint64_t value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.tctokensendertimestamp_ = value;
}
inline void Conversation::set_tctokensendertimestamp(uint64_t value) {
  _internal_set_tctokensendertimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.tcTokenSenderTimestamp)
}

// optional bool suspended = 29;
inline bool Conversation::_internal_has_suspended() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool Conversation::has_suspended() const {
  return _internal_has_suspended();
}
inline void Conversation::clear_suspended() {
  _impl_.suspended_ = false;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline bool Conversation::_internal_suspended() const {
  return _impl_.suspended_;
}
inline bool Conversation::suspended() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.suspended)
  return _internal_suspended();
}
inline void Conversation::_internal_set_suspended(bool value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.suspended_ = value;
}
inline void Conversation::set_suspended(bool value) {
  _internal_set_suspended(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.suspended)
}

// optional bool terminated = 30;
inline bool Conversation::_internal_has_terminated() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool Conversation::has_terminated() const {
  return _internal_has_terminated();
}
inline void Conversation::clear_terminated() {
  _impl_.terminated_ = false;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline bool Conversation::_internal_terminated() const {
  return _impl_.terminated_;
}
inline bool Conversation::terminated() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.terminated)
  return _internal_terminated();
}
inline void Conversation::_internal_set_terminated(bool value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.terminated_ = value;
}
inline void Conversation::set_terminated(bool value) {
  _internal_set_terminated(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.terminated)
}

// optional uint64 createdAt = 31;
inline bool Conversation::_internal_has_createdat() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool Conversation::has_createdat() const {
  return _internal_has_createdat();
}
inline void Conversation::clear_createdat() {
  _impl_.createdat_ = uint64_t{0u};
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline uint64_t Conversation::_internal_createdat() const {
  return _impl_.createdat_;
}
inline uint64_t Conversation::createdat() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.createdAt)
  return _internal_createdat();
}
inline void Conversation::_internal_set_createdat(uint64_t value) {
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.createdat_ = value;
}
inline void Conversation::set_createdat(uint64_t value) {
  _internal_set_createdat(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.createdAt)
}

// optional string createdBy = 32;
inline bool Conversation::_internal_has_createdby() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Conversation::has_createdby() const {
  return _internal_has_createdby();
}
inline void Conversation::clear_createdby() {
  _impl_.createdby_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Conversation::createdby() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.createdBy)
  return _internal_createdby();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_createdby(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.createdby_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.createdBy)
}
inline std::string* Conversation::mutable_createdby() {
  std::string* _s = _internal_mutable_createdby();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.createdBy)
  return _s;
}
inline const std::string& Conversation::_internal_createdby() const {
  return _impl_.createdby_.Get();
}
inline void Conversation::_internal_set_createdby(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.createdby_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_createdby() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.createdby_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_createdby() {
  // @@protoc_insertion_point(field_release:proto.Conversation.createdBy)
  if (!_internal_has_createdby()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.createdby_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.createdby_.IsDefault()) {
    _impl_.createdby_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_createdby(std::string* createdby) {
  if (createdby != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.createdby_.SetAllocated(createdby, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.createdby_.IsDefault()) {
    _impl_.createdby_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.createdBy)
}

// optional string description = 33;
inline bool Conversation::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Conversation::has_description() const {
  return _internal_has_description();
}
inline void Conversation::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Conversation::description() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.description)
}
inline std::string* Conversation::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.description)
  return _s;
}
inline const std::string& Conversation::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Conversation::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_description() {
  // @@protoc_insertion_point(field_release:proto.Conversation.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.description)
}

// optional bool support = 34;
inline bool Conversation::_internal_has_support() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool Conversation::has_support() const {
  return _internal_has_support();
}
inline void Conversation::clear_support() {
  _impl_.support_ = false;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline bool Conversation::_internal_support() const {
  return _impl_.support_;
}
inline bool Conversation::support() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.support)
  return _internal_support();
}
inline void Conversation::_internal_set_support(bool value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.support_ = value;
}
inline void Conversation::set_support(bool value) {
  _internal_set_support(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.support)
}

// optional bool isParentGroup = 35;
inline bool Conversation::_internal_has_isparentgroup() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool Conversation::has_isparentgroup() const {
  return _internal_has_isparentgroup();
}
inline void Conversation::clear_isparentgroup() {
  _impl_.isparentgroup_ = false;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline bool Conversation::_internal_isparentgroup() const {
  return _impl_.isparentgroup_;
}
inline bool Conversation::isparentgroup() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.isParentGroup)
  return _internal_isparentgroup();
}
inline void Conversation::_internal_set_isparentgroup(bool value) {
  _impl_._has_bits_[1] |= 0x00000008u;
  _impl_.isparentgroup_ = value;
}
inline void Conversation::set_isparentgroup(bool value) {
  _internal_set_isparentgroup(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.isParentGroup)
}

// optional bool isDefaultSubgroup = 36;
inline bool Conversation::_internal_has_isdefaultsubgroup() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool Conversation::has_isdefaultsubgroup() const {
  return _internal_has_isdefaultsubgroup();
}
inline void Conversation::clear_isdefaultsubgroup() {
  _impl_.isdefaultsubgroup_ = false;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline bool Conversation::_internal_isdefaultsubgroup() const {
  return _impl_.isdefaultsubgroup_;
}
inline bool Conversation::isdefaultsubgroup() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.isDefaultSubgroup)
  return _internal_isdefaultsubgroup();
}
inline void Conversation::_internal_set_isdefaultsubgroup(bool value) {
  _impl_._has_bits_[1] |= 0x00000010u;
  _impl_.isdefaultsubgroup_ = value;
}
inline void Conversation::set_isdefaultsubgroup(bool value) {
  _internal_set_isdefaultsubgroup(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.isDefaultSubgroup)
}

// optional string parentGroupId = 37;
inline bool Conversation::_internal_has_parentgroupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Conversation::has_parentgroupid() const {
  return _internal_has_parentgroupid();
}
inline void Conversation::clear_parentgroupid() {
  _impl_.parentgroupid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Conversation::parentgroupid() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.parentGroupId)
  return _internal_parentgroupid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_parentgroupid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.parentgroupid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.parentGroupId)
}
inline std::string* Conversation::mutable_parentgroupid() {
  std::string* _s = _internal_mutable_parentgroupid();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.parentGroupId)
  return _s;
}
inline const std::string& Conversation::_internal_parentgroupid() const {
  return _impl_.parentgroupid_.Get();
}
inline void Conversation::_internal_set_parentgroupid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.parentgroupid_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_parentgroupid() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.parentgroupid_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_parentgroupid() {
  // @@protoc_insertion_point(field_release:proto.Conversation.parentGroupId)
  if (!_internal_has_parentgroupid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.parentgroupid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentgroupid_.IsDefault()) {
    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_parentgroupid(std::string* parentgroupid) {
  if (parentgroupid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.parentgroupid_.SetAllocated(parentgroupid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.parentgroupid_.IsDefault()) {
    _impl_.parentgroupid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.parentGroupId)
}

// optional string displayName = 38;
inline bool Conversation::_internal_has_displayname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Conversation::has_displayname() const {
  return _internal_has_displayname();
}
inline void Conversation::clear_displayname() {
  _impl_.displayname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Conversation::displayname() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.displayName)
  return _internal_displayname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_displayname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.displayname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.displayName)
}
inline std::string* Conversation::mutable_displayname() {
  std::string* _s = _internal_mutable_displayname();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.displayName)
  return _s;
}
inline const std::string& Conversation::_internal_displayname() const {
  return _impl_.displayname_.Get();
}
inline void Conversation::_internal_set_displayname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.displayname_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_displayname() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.displayname_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_displayname() {
  // @@protoc_insertion_point(field_release:proto.Conversation.displayName)
  if (!_internal_has_displayname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  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 Conversation::set_allocated_displayname(std::string* displayname) {
  if (displayname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _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:proto.Conversation.displayName)
}

// optional string pnJid = 39;
inline bool Conversation::_internal_has_pnjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Conversation::has_pnjid() const {
  return _internal_has_pnjid();
}
inline void Conversation::clear_pnjid() {
  _impl_.pnjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Conversation::pnjid() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.pnJid)
  return _internal_pnjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Conversation::set_pnjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.pnjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Conversation.pnJid)
}
inline std::string* Conversation::mutable_pnjid() {
  std::string* _s = _internal_mutable_pnjid();
  // @@protoc_insertion_point(field_mutable:proto.Conversation.pnJid)
  return _s;
}
inline const std::string& Conversation::_internal_pnjid() const {
  return _impl_.pnjid_.Get();
}
inline void Conversation::_internal_set_pnjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.pnjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Conversation::_internal_mutable_pnjid() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.pnjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Conversation::release_pnjid() {
  // @@protoc_insertion_point(field_release:proto.Conversation.pnJid)
  if (!_internal_has_pnjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.pnjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pnjid_.IsDefault()) {
    _impl_.pnjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Conversation::set_allocated_pnjid(std::string* pnjid) {
  if (pnjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.pnjid_.SetAllocated(pnjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pnjid_.IsDefault()) {
    _impl_.pnjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Conversation.pnJid)
}

// optional bool selfPnExposed = 40;
inline bool Conversation::_internal_has_selfpnexposed() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool Conversation::has_selfpnexposed() const {
  return _internal_has_selfpnexposed();
}
inline void Conversation::clear_selfpnexposed() {
  _impl_.selfpnexposed_ = false;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline bool Conversation::_internal_selfpnexposed() const {
  return _impl_.selfpnexposed_;
}
inline bool Conversation::selfpnexposed() const {
  // @@protoc_insertion_point(field_get:proto.Conversation.selfPnExposed)
  return _internal_selfpnexposed();
}
inline void Conversation::_internal_set_selfpnexposed(bool value) {
  _impl_._has_bits_[1] |= 0x00000020u;
  _impl_.selfpnexposed_ = value;
}
inline void Conversation::set_selfpnexposed(bool value) {
  _internal_set_selfpnexposed(value);
  // @@protoc_insertion_point(field_set:proto.Conversation.selfPnExposed)
}

// -------------------------------------------------------------------

// DeviceListMetadata

// optional bytes senderKeyHash = 1;
inline bool DeviceListMetadata::_internal_has_senderkeyhash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceListMetadata::has_senderkeyhash() const {
  return _internal_has_senderkeyhash();
}
inline void DeviceListMetadata::clear_senderkeyhash() {
  _impl_.senderkeyhash_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceListMetadata::senderkeyhash() const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyHash)
  return _internal_senderkeyhash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceListMetadata::set_senderkeyhash(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.senderkeyhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyHash)
}
inline std::string* DeviceListMetadata::mutable_senderkeyhash() {
  std::string* _s = _internal_mutable_senderkeyhash();
  // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.senderKeyHash)
  return _s;
}
inline const std::string& DeviceListMetadata::_internal_senderkeyhash() const {
  return _impl_.senderkeyhash_.Get();
}
inline void DeviceListMetadata::_internal_set_senderkeyhash(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.senderkeyhash_.Set(value, GetArenaForAllocation());
}
inline std::string* DeviceListMetadata::_internal_mutable_senderkeyhash() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.senderkeyhash_.Mutable(GetArenaForAllocation());
}
inline std::string* DeviceListMetadata::release_senderkeyhash() {
  // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.senderKeyHash)
  if (!_internal_has_senderkeyhash()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.senderkeyhash_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderkeyhash_.IsDefault()) {
    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceListMetadata::set_allocated_senderkeyhash(std::string* senderkeyhash) {
  if (senderkeyhash != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.senderkeyhash_.SetAllocated(senderkeyhash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.senderkeyhash_.IsDefault()) {
    _impl_.senderkeyhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.senderKeyHash)
}

// optional uint64 senderTimestamp = 2;
inline bool DeviceListMetadata::_internal_has_sendertimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceListMetadata::has_sendertimestamp() const {
  return _internal_has_sendertimestamp();
}
inline void DeviceListMetadata::clear_sendertimestamp() {
  _impl_.sendertimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t DeviceListMetadata::_internal_sendertimestamp() const {
  return _impl_.sendertimestamp_;
}
inline uint64_t DeviceListMetadata::sendertimestamp() const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderTimestamp)
  return _internal_sendertimestamp();
}
inline void DeviceListMetadata::_internal_set_sendertimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sendertimestamp_ = value;
}
inline void DeviceListMetadata::set_sendertimestamp(uint64_t value) {
  _internal_set_sendertimestamp(value);
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderTimestamp)
}

// repeated uint32 senderKeyIndexes = 3 [packed = true];
inline int DeviceListMetadata::_internal_senderkeyindexes_size() const {
  return _impl_.senderkeyindexes_.size();
}
inline int DeviceListMetadata::senderkeyindexes_size() const {
  return _internal_senderkeyindexes_size();
}
inline void DeviceListMetadata::clear_senderkeyindexes() {
  _impl_.senderkeyindexes_.Clear();
}
inline uint32_t DeviceListMetadata::_internal_senderkeyindexes(int index) const {
  return _impl_.senderkeyindexes_.Get(index);
}
inline uint32_t DeviceListMetadata::senderkeyindexes(int index) const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.senderKeyIndexes)
  return _internal_senderkeyindexes(index);
}
inline void DeviceListMetadata::set_senderkeyindexes(int index, uint32_t value) {
  _impl_.senderkeyindexes_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.senderKeyIndexes)
}
inline void DeviceListMetadata::_internal_add_senderkeyindexes(uint32_t value) {
  _impl_.senderkeyindexes_.Add(value);
}
inline void DeviceListMetadata::add_senderkeyindexes(uint32_t value) {
  _internal_add_senderkeyindexes(value);
  // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.senderKeyIndexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DeviceListMetadata::_internal_senderkeyindexes() const {
  return _impl_.senderkeyindexes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DeviceListMetadata::senderkeyindexes() const {
  // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.senderKeyIndexes)
  return _internal_senderkeyindexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DeviceListMetadata::_internal_mutable_senderkeyindexes() {
  return &_impl_.senderkeyindexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DeviceListMetadata::mutable_senderkeyindexes() {
  // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.senderKeyIndexes)
  return _internal_mutable_senderkeyindexes();
}

// optional bytes recipientKeyHash = 8;
inline bool DeviceListMetadata::_internal_has_recipientkeyhash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceListMetadata::has_recipientkeyhash() const {
  return _internal_has_recipientkeyhash();
}
inline void DeviceListMetadata::clear_recipientkeyhash() {
  _impl_.recipientkeyhash_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& DeviceListMetadata::recipientkeyhash() const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyHash)
  return _internal_recipientkeyhash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceListMetadata::set_recipientkeyhash(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.recipientkeyhash_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyHash)
}
inline std::string* DeviceListMetadata::mutable_recipientkeyhash() {
  std::string* _s = _internal_mutable_recipientkeyhash();
  // @@protoc_insertion_point(field_mutable:proto.DeviceListMetadata.recipientKeyHash)
  return _s;
}
inline const std::string& DeviceListMetadata::_internal_recipientkeyhash() const {
  return _impl_.recipientkeyhash_.Get();
}
inline void DeviceListMetadata::_internal_set_recipientkeyhash(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.recipientkeyhash_.Set(value, GetArenaForAllocation());
}
inline std::string* DeviceListMetadata::_internal_mutable_recipientkeyhash() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.recipientkeyhash_.Mutable(GetArenaForAllocation());
}
inline std::string* DeviceListMetadata::release_recipientkeyhash() {
  // @@protoc_insertion_point(field_release:proto.DeviceListMetadata.recipientKeyHash)
  if (!_internal_has_recipientkeyhash()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.recipientkeyhash_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.recipientkeyhash_.IsDefault()) {
    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceListMetadata::set_allocated_recipientkeyhash(std::string* recipientkeyhash) {
  if (recipientkeyhash != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.recipientkeyhash_.SetAllocated(recipientkeyhash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.recipientkeyhash_.IsDefault()) {
    _impl_.recipientkeyhash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.DeviceListMetadata.recipientKeyHash)
}

// optional uint64 recipientTimestamp = 9;
inline bool DeviceListMetadata::_internal_has_recipienttimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DeviceListMetadata::has_recipienttimestamp() const {
  return _internal_has_recipienttimestamp();
}
inline void DeviceListMetadata::clear_recipienttimestamp() {
  _impl_.recipienttimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t DeviceListMetadata::_internal_recipienttimestamp() const {
  return _impl_.recipienttimestamp_;
}
inline uint64_t DeviceListMetadata::recipienttimestamp() const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientTimestamp)
  return _internal_recipienttimestamp();
}
inline void DeviceListMetadata::_internal_set_recipienttimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.recipienttimestamp_ = value;
}
inline void DeviceListMetadata::set_recipienttimestamp(uint64_t value) {
  _internal_set_recipienttimestamp(value);
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientTimestamp)
}

// repeated uint32 recipientKeyIndexes = 10 [packed = true];
inline int DeviceListMetadata::_internal_recipientkeyindexes_size() const {
  return _impl_.recipientkeyindexes_.size();
}
inline int DeviceListMetadata::recipientkeyindexes_size() const {
  return _internal_recipientkeyindexes_size();
}
inline void DeviceListMetadata::clear_recipientkeyindexes() {
  _impl_.recipientkeyindexes_.Clear();
}
inline uint32_t DeviceListMetadata::_internal_recipientkeyindexes(int index) const {
  return _impl_.recipientkeyindexes_.Get(index);
}
inline uint32_t DeviceListMetadata::recipientkeyindexes(int index) const {
  // @@protoc_insertion_point(field_get:proto.DeviceListMetadata.recipientKeyIndexes)
  return _internal_recipientkeyindexes(index);
}
inline void DeviceListMetadata::set_recipientkeyindexes(int index, uint32_t value) {
  _impl_.recipientkeyindexes_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.DeviceListMetadata.recipientKeyIndexes)
}
inline void DeviceListMetadata::_internal_add_recipientkeyindexes(uint32_t value) {
  _impl_.recipientkeyindexes_.Add(value);
}
inline void DeviceListMetadata::add_recipientkeyindexes(uint32_t value) {
  _internal_add_recipientkeyindexes(value);
  // @@protoc_insertion_point(field_add:proto.DeviceListMetadata.recipientKeyIndexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DeviceListMetadata::_internal_recipientkeyindexes() const {
  return _impl_.recipientkeyindexes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
DeviceListMetadata::recipientkeyindexes() const {
  // @@protoc_insertion_point(field_list:proto.DeviceListMetadata.recipientKeyIndexes)
  return _internal_recipientkeyindexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DeviceListMetadata::_internal_mutable_recipientkeyindexes() {
  return &_impl_.recipientkeyindexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
DeviceListMetadata::mutable_recipientkeyindexes() {
  // @@protoc_insertion_point(field_mutable_list:proto.DeviceListMetadata.recipientKeyIndexes)
  return _internal_mutable_recipientkeyindexes();
}

// -------------------------------------------------------------------

// DeviceProps_AppVersion

// optional uint32 primary = 1;
inline bool DeviceProps_AppVersion::_internal_has_primary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceProps_AppVersion::has_primary() const {
  return _internal_has_primary();
}
inline void DeviceProps_AppVersion::clear_primary() {
  _impl_.primary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t DeviceProps_AppVersion::_internal_primary() const {
  return _impl_.primary_;
}
inline uint32_t DeviceProps_AppVersion::primary() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.primary)
  return _internal_primary();
}
inline void DeviceProps_AppVersion::_internal_set_primary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.primary_ = value;
}
inline void DeviceProps_AppVersion::set_primary(uint32_t value) {
  _internal_set_primary(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.primary)
}

// optional uint32 secondary = 2;
inline bool DeviceProps_AppVersion::_internal_has_secondary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool DeviceProps_AppVersion::has_secondary() const {
  return _internal_has_secondary();
}
inline void DeviceProps_AppVersion::clear_secondary() {
  _impl_.secondary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t DeviceProps_AppVersion::_internal_secondary() const {
  return _impl_.secondary_;
}
inline uint32_t DeviceProps_AppVersion::secondary() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.secondary)
  return _internal_secondary();
}
inline void DeviceProps_AppVersion::_internal_set_secondary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.secondary_ = value;
}
inline void DeviceProps_AppVersion::set_secondary(uint32_t value) {
  _internal_set_secondary(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.secondary)
}

// optional uint32 tertiary = 3;
inline bool DeviceProps_AppVersion::_internal_has_tertiary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceProps_AppVersion::has_tertiary() const {
  return _internal_has_tertiary();
}
inline void DeviceProps_AppVersion::clear_tertiary() {
  _impl_.tertiary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t DeviceProps_AppVersion::_internal_tertiary() const {
  return _impl_.tertiary_;
}
inline uint32_t DeviceProps_AppVersion::tertiary() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.tertiary)
  return _internal_tertiary();
}
inline void DeviceProps_AppVersion::_internal_set_tertiary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.tertiary_ = value;
}
inline void DeviceProps_AppVersion::set_tertiary(uint32_t value) {
  _internal_set_tertiary(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.tertiary)
}

// optional uint32 quaternary = 4;
inline bool DeviceProps_AppVersion::_internal_has_quaternary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DeviceProps_AppVersion::has_quaternary() const {
  return _internal_has_quaternary();
}
inline void DeviceProps_AppVersion::clear_quaternary() {
  _impl_.quaternary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t DeviceProps_AppVersion::_internal_quaternary() const {
  return _impl_.quaternary_;
}
inline uint32_t DeviceProps_AppVersion::quaternary() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quaternary)
  return _internal_quaternary();
}
inline void DeviceProps_AppVersion::_internal_set_quaternary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.quaternary_ = value;
}
inline void DeviceProps_AppVersion::set_quaternary(uint32_t value) {
  _internal_set_quaternary(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quaternary)
}

// optional uint32 quinary = 5;
inline bool DeviceProps_AppVersion::_internal_has_quinary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool DeviceProps_AppVersion::has_quinary() const {
  return _internal_has_quinary();
}
inline void DeviceProps_AppVersion::clear_quinary() {
  _impl_.quinary_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t DeviceProps_AppVersion::_internal_quinary() const {
  return _impl_.quinary_;
}
inline uint32_t DeviceProps_AppVersion::quinary() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.AppVersion.quinary)
  return _internal_quinary();
}
inline void DeviceProps_AppVersion::_internal_set_quinary(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.quinary_ = value;
}
inline void DeviceProps_AppVersion::set_quinary(uint32_t value) {
  _internal_set_quinary(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.AppVersion.quinary)
}

// -------------------------------------------------------------------

// DeviceProps

// optional string os = 1;
inline bool DeviceProps::_internal_has_os() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DeviceProps::has_os() const {
  return _internal_has_os();
}
inline void DeviceProps::clear_os() {
  _impl_.os_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceProps::os() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.os)
  return _internal_os();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceProps::set_os(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.os_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.DeviceProps.os)
}
inline std::string* DeviceProps::mutable_os() {
  std::string* _s = _internal_mutable_os();
  // @@protoc_insertion_point(field_mutable:proto.DeviceProps.os)
  return _s;
}
inline const std::string& DeviceProps::_internal_os() const {
  return _impl_.os_.Get();
}
inline void DeviceProps::_internal_set_os(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.os_.Set(value, GetArenaForAllocation());
}
inline std::string* DeviceProps::_internal_mutable_os() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.os_.Mutable(GetArenaForAllocation());
}
inline std::string* DeviceProps::release_os() {
  // @@protoc_insertion_point(field_release:proto.DeviceProps.os)
  if (!_internal_has_os()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.os_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.os_.IsDefault()) {
    _impl_.os_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void DeviceProps::set_allocated_os(std::string* os) {
  if (os != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.os_.SetAllocated(os, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.os_.IsDefault()) {
    _impl_.os_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.os)
}

// optional .proto.DeviceProps.AppVersion version = 2;
inline bool DeviceProps::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
  return value;
}
inline bool DeviceProps::has_version() const {
  return _internal_has_version();
}
inline void DeviceProps::clear_version() {
  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::DeviceProps_AppVersion& DeviceProps::_internal_version() const {
  const ::proto::DeviceProps_AppVersion* p = _impl_.version_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::DeviceProps_AppVersion&>(
      ::proto::_DeviceProps_AppVersion_default_instance_);
}
inline const ::proto::DeviceProps_AppVersion& DeviceProps::version() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.version)
  return _internal_version();
}
inline void DeviceProps::unsafe_arena_set_allocated_version(
    ::proto::DeviceProps_AppVersion* version) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
  }
  _impl_.version_ = version;
  if (version) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.DeviceProps.version)
}
inline ::proto::DeviceProps_AppVersion* DeviceProps::release_version() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::DeviceProps_AppVersion* temp = _impl_.version_;
  _impl_.version_ = 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 ::proto::DeviceProps_AppVersion* DeviceProps::unsafe_arena_release_version() {
  // @@protoc_insertion_point(field_release:proto.DeviceProps.version)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::DeviceProps_AppVersion* temp = _impl_.version_;
  _impl_.version_ = nullptr;
  return temp;
}
inline ::proto::DeviceProps_AppVersion* DeviceProps::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.version_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::DeviceProps_AppVersion>(GetArenaForAllocation());
    _impl_.version_ = p;
  }
  return _impl_.version_;
}
inline ::proto::DeviceProps_AppVersion* DeviceProps::mutable_version() {
  ::proto::DeviceProps_AppVersion* _msg = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:proto.DeviceProps.version)
  return _msg;
}
inline void DeviceProps::set_allocated_version(::proto::DeviceProps_AppVersion* version) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.version_;
  }
  if (version) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
    if (message_arena != submessage_arena) {
      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, version, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.version_ = version;
  // @@protoc_insertion_point(field_set_allocated:proto.DeviceProps.version)
}

// optional .proto.DeviceProps.PlatformType platformType = 3;
inline bool DeviceProps::_internal_has_platformtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool DeviceProps::has_platformtype() const {
  return _internal_has_platformtype();
}
inline void DeviceProps::clear_platformtype() {
  _impl_.platformtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::DeviceProps_PlatformType DeviceProps::_internal_platformtype() const {
  return static_cast< ::proto::DeviceProps_PlatformType >(_impl_.platformtype_);
}
inline ::proto::DeviceProps_PlatformType DeviceProps::platformtype() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.platformType)
  return _internal_platformtype();
}
inline void DeviceProps::_internal_set_platformtype(::proto::DeviceProps_PlatformType value) {
  assert(::proto::DeviceProps_PlatformType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.platformtype_ = value;
}
inline void DeviceProps::set_platformtype(::proto::DeviceProps_PlatformType value) {
  _internal_set_platformtype(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.platformType)
}

// optional bool requireFullSync = 4;
inline bool DeviceProps::_internal_has_requirefullsync() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool DeviceProps::has_requirefullsync() const {
  return _internal_has_requirefullsync();
}
inline void DeviceProps::clear_requirefullsync() {
  _impl_.requirefullsync_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool DeviceProps::_internal_requirefullsync() const {
  return _impl_.requirefullsync_;
}
inline bool DeviceProps::requirefullsync() const {
  // @@protoc_insertion_point(field_get:proto.DeviceProps.requireFullSync)
  return _internal_requirefullsync();
}
inline void DeviceProps::_internal_set_requirefullsync(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.requirefullsync_ = value;
}
inline void DeviceProps::set_requirefullsync(bool value) {
  _internal_set_requirefullsync(value);
  // @@protoc_insertion_point(field_set:proto.DeviceProps.requireFullSync)
}

// -------------------------------------------------------------------

// DisappearingMode

// optional .proto.DisappearingMode.Initiator initiator = 1;
inline bool DisappearingMode::_internal_has_initiator() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool DisappearingMode::has_initiator() const {
  return _internal_has_initiator();
}
inline void DisappearingMode::clear_initiator() {
  _impl_.initiator_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::proto::DisappearingMode_Initiator DisappearingMode::_internal_initiator() const {
  return static_cast< ::proto::DisappearingMode_Initiator >(_impl_.initiator_);
}
inline ::proto::DisappearingMode_Initiator DisappearingMode::initiator() const {
  // @@protoc_insertion_point(field_get:proto.DisappearingMode.initiator)
  return _internal_initiator();
}
inline void DisappearingMode::_internal_set_initiator(::proto::DisappearingMode_Initiator value) {
  assert(::proto::DisappearingMode_Initiator_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.initiator_ = value;
}
inline void DisappearingMode::set_initiator(::proto::DisappearingMode_Initiator value) {
  _internal_set_initiator(value);
  // @@protoc_insertion_point(field_set:proto.DisappearingMode.initiator)
}

// -------------------------------------------------------------------

// EphemeralSetting

// optional sfixed32 duration = 1;
inline bool EphemeralSetting::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool EphemeralSetting::has_duration() const {
  return _internal_has_duration();
}
inline void EphemeralSetting::clear_duration() {
  _impl_.duration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t EphemeralSetting::_internal_duration() const {
  return _impl_.duration_;
}
inline int32_t EphemeralSetting::duration() const {
  // @@protoc_insertion_point(field_get:proto.EphemeralSetting.duration)
  return _internal_duration();
}
inline void EphemeralSetting::_internal_set_duration(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.duration_ = value;
}
inline void EphemeralSetting::set_duration(int32_t value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:proto.EphemeralSetting.duration)
}

// optional sfixed64 timestamp = 2;
inline bool EphemeralSetting::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool EphemeralSetting::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void EphemeralSetting::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t EphemeralSetting::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t EphemeralSetting::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.EphemeralSetting.timestamp)
  return _internal_timestamp();
}
inline void EphemeralSetting::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void EphemeralSetting::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.EphemeralSetting.timestamp)
}

// -------------------------------------------------------------------

// ExitCode

// optional uint64 code = 1;
inline bool ExitCode::_internal_has_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExitCode::has_code() const {
  return _internal_has_code();
}
inline void ExitCode::clear_code() {
  _impl_.code_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t ExitCode::_internal_code() const {
  return _impl_.code_;
}
inline uint64_t ExitCode::code() const {
  // @@protoc_insertion_point(field_get:proto.ExitCode.code)
  return _internal_code();
}
inline void ExitCode::_internal_set_code(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.code_ = value;
}
inline void ExitCode::set_code(uint64_t value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:proto.ExitCode.code)
}

// optional string text = 2;
inline bool ExitCode::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExitCode::has_text() const {
  return _internal_has_text();
}
inline void ExitCode::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ExitCode::text() const {
  // @@protoc_insertion_point(field_get:proto.ExitCode.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExitCode::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExitCode.text)
}
inline std::string* ExitCode::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.ExitCode.text)
  return _s;
}
inline const std::string& ExitCode::_internal_text() const {
  return _impl_.text_.Get();
}
inline void ExitCode::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* ExitCode::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* ExitCode::release_text() {
  // @@protoc_insertion_point(field_release:proto.ExitCode.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 ExitCode::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.ExitCode.text)
}

// -------------------------------------------------------------------

// ExternalBlobReference

// optional bytes mediaKey = 1;
inline bool ExternalBlobReference::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void ExternalBlobReference::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ExternalBlobReference::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalBlobReference::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.mediaKey)
}
inline std::string* ExternalBlobReference::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.mediaKey)
  return _s;
}
inline const std::string& ExternalBlobReference::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void ExternalBlobReference::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ExternalBlobReference::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.mediaKey)
}

// optional string directPath = 2;
inline bool ExternalBlobReference::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_directpath() const {
  return _internal_has_directpath();
}
inline void ExternalBlobReference::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& ExternalBlobReference::directpath() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalBlobReference::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.directPath)
}
inline std::string* ExternalBlobReference::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.directPath)
  return _s;
}
inline const std::string& ExternalBlobReference::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void ExternalBlobReference::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ExternalBlobReference::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.directPath)
}

// optional string handle = 3;
inline bool ExternalBlobReference::_internal_has_handle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_handle() const {
  return _internal_has_handle();
}
inline void ExternalBlobReference::clear_handle() {
  _impl_.handle_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& ExternalBlobReference::handle() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.handle)
  return _internal_handle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalBlobReference::set_handle(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.handle)
}
inline std::string* ExternalBlobReference::mutable_handle() {
  std::string* _s = _internal_mutable_handle();
  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.handle)
  return _s;
}
inline const std::string& ExternalBlobReference::_internal_handle() const {
  return _impl_.handle_.Get();
}
inline void ExternalBlobReference::_internal_set_handle(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.handle_.Set(value, GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::_internal_mutable_handle() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.handle_.Mutable(GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::release_handle() {
  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.handle)
  if (!_internal_has_handle()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.handle_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.handle_.IsDefault()) {
    _impl_.handle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ExternalBlobReference::set_allocated_handle(std::string* handle) {
  if (handle != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.handle_.SetAllocated(handle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.handle_.IsDefault()) {
    _impl_.handle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.handle)
}

// optional uint64 fileSizeBytes = 4;
inline bool ExternalBlobReference::_internal_has_filesizebytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_filesizebytes() const {
  return _internal_has_filesizebytes();
}
inline void ExternalBlobReference::clear_filesizebytes() {
  _impl_.filesizebytes_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t ExternalBlobReference::_internal_filesizebytes() const {
  return _impl_.filesizebytes_;
}
inline uint64_t ExternalBlobReference::filesizebytes() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSizeBytes)
  return _internal_filesizebytes();
}
inline void ExternalBlobReference::_internal_set_filesizebytes(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.filesizebytes_ = value;
}
inline void ExternalBlobReference::set_filesizebytes(uint64_t value) {
  _internal_set_filesizebytes(value);
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSizeBytes)
}

// optional bytes fileSha256 = 5;
inline bool ExternalBlobReference::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void ExternalBlobReference::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& ExternalBlobReference::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalBlobReference::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileSha256)
}
inline std::string* ExternalBlobReference::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileSha256)
  return _s;
}
inline const std::string& ExternalBlobReference::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void ExternalBlobReference::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ExternalBlobReference::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileSha256)
}

// optional bytes fileEncSha256 = 6;
inline bool ExternalBlobReference::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool ExternalBlobReference::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void ExternalBlobReference::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& ExternalBlobReference::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.ExternalBlobReference.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ExternalBlobReference::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ExternalBlobReference.fileEncSha256)
}
inline std::string* ExternalBlobReference::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.ExternalBlobReference.fileEncSha256)
  return _s;
}
inline const std::string& ExternalBlobReference::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void ExternalBlobReference::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* ExternalBlobReference::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.ExternalBlobReference.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ExternalBlobReference::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ExternalBlobReference.fileEncSha256)
}

// -------------------------------------------------------------------

// GlobalSettings

// optional .proto.WallpaperSettings lightThemeWallpaper = 1;
inline bool GlobalSettings::_internal_has_lightthemewallpaper() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lightthemewallpaper_ != nullptr);
  return value;
}
inline bool GlobalSettings::has_lightthemewallpaper() const {
  return _internal_has_lightthemewallpaper();
}
inline void GlobalSettings::clear_lightthemewallpaper() {
  if (_impl_.lightthemewallpaper_ != nullptr) _impl_.lightthemewallpaper_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::WallpaperSettings& GlobalSettings::_internal_lightthemewallpaper() const {
  const ::proto::WallpaperSettings* p = _impl_.lightthemewallpaper_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
      ::proto::_WallpaperSettings_default_instance_);
}
inline const ::proto::WallpaperSettings& GlobalSettings::lightthemewallpaper() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.lightThemeWallpaper)
  return _internal_lightthemewallpaper();
}
inline void GlobalSettings::unsafe_arena_set_allocated_lightthemewallpaper(
    ::proto::WallpaperSettings* lightthemewallpaper) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lightthemewallpaper_);
  }
  _impl_.lightthemewallpaper_ = lightthemewallpaper;
  if (lightthemewallpaper) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.lightThemeWallpaper)
}
inline ::proto::WallpaperSettings* GlobalSettings::release_lightthemewallpaper() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_;
  _impl_.lightthemewallpaper_ = 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 ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_lightthemewallpaper() {
  // @@protoc_insertion_point(field_release:proto.GlobalSettings.lightThemeWallpaper)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::WallpaperSettings* temp = _impl_.lightthemewallpaper_;
  _impl_.lightthemewallpaper_ = nullptr;
  return temp;
}
inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_lightthemewallpaper() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.lightthemewallpaper_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
    _impl_.lightthemewallpaper_ = p;
  }
  return _impl_.lightthemewallpaper_;
}
inline ::proto::WallpaperSettings* GlobalSettings::mutable_lightthemewallpaper() {
  ::proto::WallpaperSettings* _msg = _internal_mutable_lightthemewallpaper();
  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.lightThemeWallpaper)
  return _msg;
}
inline void GlobalSettings::set_allocated_lightthemewallpaper(::proto::WallpaperSettings* lightthemewallpaper) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lightthemewallpaper_;
  }
  if (lightthemewallpaper) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lightthemewallpaper);
    if (message_arena != submessage_arena) {
      lightthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lightthemewallpaper, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.lightthemewallpaper_ = lightthemewallpaper;
  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.lightThemeWallpaper)
}

// optional .proto.MediaVisibility mediaVisibility = 2;
inline bool GlobalSettings::_internal_has_mediavisibility() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool GlobalSettings::has_mediavisibility() const {
  return _internal_has_mediavisibility();
}
inline void GlobalSettings::clear_mediavisibility() {
  _impl_.mediavisibility_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::proto::MediaVisibility GlobalSettings::_internal_mediavisibility() const {
  return static_cast< ::proto::MediaVisibility >(_impl_.mediavisibility_);
}
inline ::proto::MediaVisibility GlobalSettings::mediavisibility() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.mediaVisibility)
  return _internal_mediavisibility();
}
inline void GlobalSettings::_internal_set_mediavisibility(::proto::MediaVisibility value) {
  assert(::proto::MediaVisibility_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.mediavisibility_ = value;
}
inline void GlobalSettings::set_mediavisibility(::proto::MediaVisibility value) {
  _internal_set_mediavisibility(value);
  // @@protoc_insertion_point(field_set:proto.GlobalSettings.mediaVisibility)
}

// optional .proto.WallpaperSettings darkThemeWallpaper = 3;
inline bool GlobalSettings::_internal_has_darkthemewallpaper() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.darkthemewallpaper_ != nullptr);
  return value;
}
inline bool GlobalSettings::has_darkthemewallpaper() const {
  return _internal_has_darkthemewallpaper();
}
inline void GlobalSettings::clear_darkthemewallpaper() {
  if (_impl_.darkthemewallpaper_ != nullptr) _impl_.darkthemewallpaper_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::WallpaperSettings& GlobalSettings::_internal_darkthemewallpaper() const {
  const ::proto::WallpaperSettings* p = _impl_.darkthemewallpaper_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::WallpaperSettings&>(
      ::proto::_WallpaperSettings_default_instance_);
}
inline const ::proto::WallpaperSettings& GlobalSettings::darkthemewallpaper() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.darkThemeWallpaper)
  return _internal_darkthemewallpaper();
}
inline void GlobalSettings::unsafe_arena_set_allocated_darkthemewallpaper(
    ::proto::WallpaperSettings* darkthemewallpaper) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.darkthemewallpaper_);
  }
  _impl_.darkthemewallpaper_ = darkthemewallpaper;
  if (darkthemewallpaper) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.darkThemeWallpaper)
}
inline ::proto::WallpaperSettings* GlobalSettings::release_darkthemewallpaper() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_;
  _impl_.darkthemewallpaper_ = 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 ::proto::WallpaperSettings* GlobalSettings::unsafe_arena_release_darkthemewallpaper() {
  // @@protoc_insertion_point(field_release:proto.GlobalSettings.darkThemeWallpaper)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::WallpaperSettings* temp = _impl_.darkthemewallpaper_;
  _impl_.darkthemewallpaper_ = nullptr;
  return temp;
}
inline ::proto::WallpaperSettings* GlobalSettings::_internal_mutable_darkthemewallpaper() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.darkthemewallpaper_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::WallpaperSettings>(GetArenaForAllocation());
    _impl_.darkthemewallpaper_ = p;
  }
  return _impl_.darkthemewallpaper_;
}
inline ::proto::WallpaperSettings* GlobalSettings::mutable_darkthemewallpaper() {
  ::proto::WallpaperSettings* _msg = _internal_mutable_darkthemewallpaper();
  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.darkThemeWallpaper)
  return _msg;
}
inline void GlobalSettings::set_allocated_darkthemewallpaper(::proto::WallpaperSettings* darkthemewallpaper) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.darkthemewallpaper_;
  }
  if (darkthemewallpaper) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(darkthemewallpaper);
    if (message_arena != submessage_arena) {
      darkthemewallpaper = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, darkthemewallpaper, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.darkthemewallpaper_ = darkthemewallpaper;
  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.darkThemeWallpaper)
}

// optional .proto.AutoDownloadSettings autoDownloadWiFi = 4;
inline bool GlobalSettings::_internal_has_autodownloadwifi() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.autodownloadwifi_ != nullptr);
  return value;
}
inline bool GlobalSettings::has_autodownloadwifi() const {
  return _internal_has_autodownloadwifi();
}
inline void GlobalSettings::clear_autodownloadwifi() {
  if (_impl_.autodownloadwifi_ != nullptr) _impl_.autodownloadwifi_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadwifi() const {
  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadwifi_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
      ::proto::_AutoDownloadSettings_default_instance_);
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadwifi() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadWiFi)
  return _internal_autodownloadwifi();
}
inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadwifi(
    ::proto::AutoDownloadSettings* autodownloadwifi) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadwifi_);
  }
  _impl_.autodownloadwifi_ = autodownloadwifi;
  if (autodownloadwifi) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadWiFi)
}
inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadwifi() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_;
  _impl_.autodownloadwifi_ = 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 ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadwifi() {
  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadWiFi)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadwifi_;
  _impl_.autodownloadwifi_ = nullptr;
  return temp;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadwifi() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.autodownloadwifi_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
    _impl_.autodownloadwifi_ = p;
  }
  return _impl_.autodownloadwifi_;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadwifi() {
  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadwifi();
  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadWiFi)
  return _msg;
}
inline void GlobalSettings::set_allocated_autodownloadwifi(::proto::AutoDownloadSettings* autodownloadwifi) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.autodownloadwifi_;
  }
  if (autodownloadwifi) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadwifi);
    if (message_arena != submessage_arena) {
      autodownloadwifi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, autodownloadwifi, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.autodownloadwifi_ = autodownloadwifi;
  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadWiFi)
}

// optional .proto.AutoDownloadSettings autoDownloadCellular = 5;
inline bool GlobalSettings::_internal_has_autodownloadcellular() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.autodownloadcellular_ != nullptr);
  return value;
}
inline bool GlobalSettings::has_autodownloadcellular() const {
  return _internal_has_autodownloadcellular();
}
inline void GlobalSettings::clear_autodownloadcellular() {
  if (_impl_.autodownloadcellular_ != nullptr) _impl_.autodownloadcellular_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadcellular() const {
  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadcellular_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
      ::proto::_AutoDownloadSettings_default_instance_);
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadcellular() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadCellular)
  return _internal_autodownloadcellular();
}
inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadcellular(
    ::proto::AutoDownloadSettings* autodownloadcellular) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadcellular_);
  }
  _impl_.autodownloadcellular_ = autodownloadcellular;
  if (autodownloadcellular) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadCellular)
}
inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadcellular() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_;
  _impl_.autodownloadcellular_ = 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 ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadcellular() {
  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadCellular)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadcellular_;
  _impl_.autodownloadcellular_ = nullptr;
  return temp;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadcellular() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.autodownloadcellular_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
    _impl_.autodownloadcellular_ = p;
  }
  return _impl_.autodownloadcellular_;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadcellular() {
  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadcellular();
  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadCellular)
  return _msg;
}
inline void GlobalSettings::set_allocated_autodownloadcellular(::proto::AutoDownloadSettings* autodownloadcellular) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.autodownloadcellular_;
  }
  if (autodownloadcellular) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadcellular);
    if (message_arena != submessage_arena) {
      autodownloadcellular = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, autodownloadcellular, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.autodownloadcellular_ = autodownloadcellular;
  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadCellular)
}

// optional .proto.AutoDownloadSettings autoDownloadRoaming = 6;
inline bool GlobalSettings::_internal_has_autodownloadroaming() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.autodownloadroaming_ != nullptr);
  return value;
}
inline bool GlobalSettings::has_autodownloadroaming() const {
  return _internal_has_autodownloadroaming();
}
inline void GlobalSettings::clear_autodownloadroaming() {
  if (_impl_.autodownloadroaming_ != nullptr) _impl_.autodownloadroaming_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::_internal_autodownloadroaming() const {
  const ::proto::AutoDownloadSettings* p = _impl_.autodownloadroaming_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::AutoDownloadSettings&>(
      ::proto::_AutoDownloadSettings_default_instance_);
}
inline const ::proto::AutoDownloadSettings& GlobalSettings::autodownloadroaming() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.autoDownloadRoaming)
  return _internal_autodownloadroaming();
}
inline void GlobalSettings::unsafe_arena_set_allocated_autodownloadroaming(
    ::proto::AutoDownloadSettings* autodownloadroaming) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.autodownloadroaming_);
  }
  _impl_.autodownloadroaming_ = autodownloadroaming;
  if (autodownloadroaming) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.GlobalSettings.autoDownloadRoaming)
}
inline ::proto::AutoDownloadSettings* GlobalSettings::release_autodownloadroaming() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_;
  _impl_.autodownloadroaming_ = 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 ::proto::AutoDownloadSettings* GlobalSettings::unsafe_arena_release_autodownloadroaming() {
  // @@protoc_insertion_point(field_release:proto.GlobalSettings.autoDownloadRoaming)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::AutoDownloadSettings* temp = _impl_.autodownloadroaming_;
  _impl_.autodownloadroaming_ = nullptr;
  return temp;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::_internal_mutable_autodownloadroaming() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.autodownloadroaming_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::AutoDownloadSettings>(GetArenaForAllocation());
    _impl_.autodownloadroaming_ = p;
  }
  return _impl_.autodownloadroaming_;
}
inline ::proto::AutoDownloadSettings* GlobalSettings::mutable_autodownloadroaming() {
  ::proto::AutoDownloadSettings* _msg = _internal_mutable_autodownloadroaming();
  // @@protoc_insertion_point(field_mutable:proto.GlobalSettings.autoDownloadRoaming)
  return _msg;
}
inline void GlobalSettings::set_allocated_autodownloadroaming(::proto::AutoDownloadSettings* autodownloadroaming) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.autodownloadroaming_;
  }
  if (autodownloadroaming) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(autodownloadroaming);
    if (message_arena != submessage_arena) {
      autodownloadroaming = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, autodownloadroaming, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.autodownloadroaming_ = autodownloadroaming;
  // @@protoc_insertion_point(field_set_allocated:proto.GlobalSettings.autoDownloadRoaming)
}

// optional bool showIndividualNotificationsPreview = 7;
inline bool GlobalSettings::_internal_has_showindividualnotificationspreview() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool GlobalSettings::has_showindividualnotificationspreview() const {
  return _internal_has_showindividualnotificationspreview();
}
inline void GlobalSettings::clear_showindividualnotificationspreview() {
  _impl_.showindividualnotificationspreview_ = false;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline bool GlobalSettings::_internal_showindividualnotificationspreview() const {
  return _impl_.showindividualnotificationspreview_;
}
inline bool GlobalSettings::showindividualnotificationspreview() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.showIndividualNotificationsPreview)
  return _internal_showindividualnotificationspreview();
}
inline void GlobalSettings::_internal_set_showindividualnotificationspreview(bool value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.showindividualnotificationspreview_ = value;
}
inline void GlobalSettings::set_showindividualnotificationspreview(bool value) {
  _internal_set_showindividualnotificationspreview(value);
  // @@protoc_insertion_point(field_set:proto.GlobalSettings.showIndividualNotificationsPreview)
}

// optional bool showGroupNotificationsPreview = 8;
inline bool GlobalSettings::_internal_has_showgroupnotificationspreview() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool GlobalSettings::has_showgroupnotificationspreview() const {
  return _internal_has_showgroupnotificationspreview();
}
inline void GlobalSettings::clear_showgroupnotificationspreview() {
  _impl_.showgroupnotificationspreview_ = false;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline bool GlobalSettings::_internal_showgroupnotificationspreview() const {
  return _impl_.showgroupnotificationspreview_;
}
inline bool GlobalSettings::showgroupnotificationspreview() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.showGroupNotificationsPreview)
  return _internal_showgroupnotificationspreview();
}
inline void GlobalSettings::_internal_set_showgroupnotificationspreview(bool value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.showgroupnotificationspreview_ = value;
}
inline void GlobalSettings::set_showgroupnotificationspreview(bool value) {
  _internal_set_showgroupnotificationspreview(value);
  // @@protoc_insertion_point(field_set:proto.GlobalSettings.showGroupNotificationsPreview)
}

// optional int32 disappearingModeDuration = 9;
inline bool GlobalSettings::_internal_has_disappearingmodeduration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool GlobalSettings::has_disappearingmodeduration() const {
  return _internal_has_disappearingmodeduration();
}
inline void GlobalSettings::clear_disappearingmodeduration() {
  _impl_.disappearingmodeduration_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t GlobalSettings::_internal_disappearingmodeduration() const {
  return _impl_.disappearingmodeduration_;
}
inline int32_t GlobalSettings::disappearingmodeduration() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeDuration)
  return _internal_disappearingmodeduration();
}
inline void GlobalSettings::_internal_set_disappearingmodeduration(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.disappearingmodeduration_ = value;
}
inline void GlobalSettings::set_disappearingmodeduration(int32_t value) {
  _internal_set_disappearingmodeduration(value);
  // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeDuration)
}

// optional int64 disappearingModeTimestamp = 10;
inline bool GlobalSettings::_internal_has_disappearingmodetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool GlobalSettings::has_disappearingmodetimestamp() const {
  return _internal_has_disappearingmodetimestamp();
}
inline void GlobalSettings::clear_disappearingmodetimestamp() {
  _impl_.disappearingmodetimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t GlobalSettings::_internal_disappearingmodetimestamp() const {
  return _impl_.disappearingmodetimestamp_;
}
inline int64_t GlobalSettings::disappearingmodetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.GlobalSettings.disappearingModeTimestamp)
  return _internal_disappearingmodetimestamp();
}
inline void GlobalSettings::_internal_set_disappearingmodetimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.disappearingmodetimestamp_ = value;
}
inline void GlobalSettings::set_disappearingmodetimestamp(int64_t value) {
  _internal_set_disappearingmodetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.GlobalSettings.disappearingModeTimestamp)
}

// -------------------------------------------------------------------

// GroupParticipant

// required string userJid = 1;
inline bool GroupParticipant::_internal_has_userjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool GroupParticipant::has_userjid() const {
  return _internal_has_userjid();
}
inline void GroupParticipant::clear_userjid() {
  _impl_.userjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& GroupParticipant::userjid() const {
  // @@protoc_insertion_point(field_get:proto.GroupParticipant.userJid)
  return _internal_userjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void GroupParticipant::set_userjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.GroupParticipant.userJid)
}
inline std::string* GroupParticipant::mutable_userjid() {
  std::string* _s = _internal_mutable_userjid();
  // @@protoc_insertion_point(field_mutable:proto.GroupParticipant.userJid)
  return _s;
}
inline const std::string& GroupParticipant::_internal_userjid() const {
  return _impl_.userjid_.Get();
}
inline void GroupParticipant::_internal_set_userjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.userjid_.Set(value, GetArenaForAllocation());
}
inline std::string* GroupParticipant::_internal_mutable_userjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.userjid_.Mutable(GetArenaForAllocation());
}
inline std::string* GroupParticipant::release_userjid() {
  // @@protoc_insertion_point(field_release:proto.GroupParticipant.userJid)
  if (!_internal_has_userjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.userjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void GroupParticipant::set_allocated_userjid(std::string* userjid) {
  if (userjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.GroupParticipant.userJid)
}

// optional .proto.GroupParticipant.Rank rank = 2;
inline bool GroupParticipant::_internal_has_rank() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool GroupParticipant::has_rank() const {
  return _internal_has_rank();
}
inline void GroupParticipant::clear_rank() {
  _impl_.rank_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::GroupParticipant_Rank GroupParticipant::_internal_rank() const {
  return static_cast< ::proto::GroupParticipant_Rank >(_impl_.rank_);
}
inline ::proto::GroupParticipant_Rank GroupParticipant::rank() const {
  // @@protoc_insertion_point(field_get:proto.GroupParticipant.rank)
  return _internal_rank();
}
inline void GroupParticipant::_internal_set_rank(::proto::GroupParticipant_Rank value) {
  assert(::proto::GroupParticipant_Rank_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rank_ = value;
}
inline void GroupParticipant::set_rank(::proto::GroupParticipant_Rank value) {
  _internal_set_rank(value);
  // @@protoc_insertion_point(field_set:proto.GroupParticipant.rank)
}

// -------------------------------------------------------------------

// HandshakeMessage_ClientFinish

// optional bytes static = 1;
inline bool HandshakeMessage_ClientFinish::_internal_has_static_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HandshakeMessage_ClientFinish::has_static_() const {
  return _internal_has_static_();
}
inline void HandshakeMessage_ClientFinish::clear_static_() {
  _impl_.static__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HandshakeMessage_ClientFinish::static_() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.static)
  return _internal_static_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ClientFinish::set_static_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.static)
}
inline std::string* HandshakeMessage_ClientFinish::mutable_static_() {
  std::string* _s = _internal_mutable_static_();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.static)
  return _s;
}
inline const std::string& HandshakeMessage_ClientFinish::_internal_static_() const {
  return _impl_.static__.Get();
}
inline void HandshakeMessage_ClientFinish::_internal_set_static_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.static__.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_static_() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.static__.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientFinish::release_static_() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.static)
  if (!_internal_has_static_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.static__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ClientFinish::set_allocated_static_(std::string* static_) {
  if (static_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.static)
}

// optional bytes payload = 2;
inline bool HandshakeMessage_ClientFinish::_internal_has_payload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HandshakeMessage_ClientFinish::has_payload() const {
  return _internal_has_payload();
}
inline void HandshakeMessage_ClientFinish::clear_payload() {
  _impl_.payload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HandshakeMessage_ClientFinish::payload() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientFinish.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ClientFinish::set_payload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientFinish.payload)
}
inline std::string* HandshakeMessage_ClientFinish::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientFinish.payload)
  return _s;
}
inline const std::string& HandshakeMessage_ClientFinish::_internal_payload() const {
  return _impl_.payload_.Get();
}
inline void HandshakeMessage_ClientFinish::_internal_set_payload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.payload_.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientFinish::_internal_mutable_payload() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.payload_.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientFinish::release_payload() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientFinish.payload)
  if (!_internal_has_payload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.payload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ClientFinish::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientFinish.payload)
}

// -------------------------------------------------------------------

// HandshakeMessage_ClientHello

// optional bytes ephemeral = 1;
inline bool HandshakeMessage_ClientHello::_internal_has_ephemeral() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HandshakeMessage_ClientHello::has_ephemeral() const {
  return _internal_has_ephemeral();
}
inline void HandshakeMessage_ClientHello::clear_ephemeral() {
  _impl_.ephemeral_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HandshakeMessage_ClientHello::ephemeral() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.ephemeral)
  return _internal_ephemeral();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ClientHello::set_ephemeral(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.ephemeral_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.ephemeral)
}
inline std::string* HandshakeMessage_ClientHello::mutable_ephemeral() {
  std::string* _s = _internal_mutable_ephemeral();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.ephemeral)
  return _s;
}
inline const std::string& HandshakeMessage_ClientHello::_internal_ephemeral() const {
  return _impl_.ephemeral_.Get();
}
inline void HandshakeMessage_ClientHello::_internal_set_ephemeral(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ephemeral_.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::_internal_mutable_ephemeral() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.ephemeral_.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::release_ephemeral() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.ephemeral)
  if (!_internal_has_ephemeral()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.ephemeral_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeral_.IsDefault()) {
    _impl_.ephemeral_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ClientHello::set_allocated_ephemeral(std::string* ephemeral) {
  if (ephemeral != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeral_.IsDefault()) {
    _impl_.ephemeral_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.ephemeral)
}

// optional bytes static = 2;
inline bool HandshakeMessage_ClientHello::_internal_has_static_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HandshakeMessage_ClientHello::has_static_() const {
  return _internal_has_static_();
}
inline void HandshakeMessage_ClientHello::clear_static_() {
  _impl_.static__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HandshakeMessage_ClientHello::static_() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.static)
  return _internal_static_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ClientHello::set_static_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.static)
}
inline std::string* HandshakeMessage_ClientHello::mutable_static_() {
  std::string* _s = _internal_mutable_static_();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.static)
  return _s;
}
inline const std::string& HandshakeMessage_ClientHello::_internal_static_() const {
  return _impl_.static__.Get();
}
inline void HandshakeMessage_ClientHello::_internal_set_static_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.static__.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::_internal_mutable_static_() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.static__.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::release_static_() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.static)
  if (!_internal_has_static_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.static__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ClientHello::set_allocated_static_(std::string* static_) {
  if (static_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.static)
}

// optional bytes payload = 3;
inline bool HandshakeMessage_ClientHello::_internal_has_payload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HandshakeMessage_ClientHello::has_payload() const {
  return _internal_has_payload();
}
inline void HandshakeMessage_ClientHello::clear_payload() {
  _impl_.payload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& HandshakeMessage_ClientHello::payload() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ClientHello.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ClientHello::set_payload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ClientHello.payload)
}
inline std::string* HandshakeMessage_ClientHello::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ClientHello.payload)
  return _s;
}
inline const std::string& HandshakeMessage_ClientHello::_internal_payload() const {
  return _impl_.payload_.Get();
}
inline void HandshakeMessage_ClientHello::_internal_set_payload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.payload_.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::_internal_mutable_payload() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.payload_.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ClientHello::release_payload() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ClientHello.payload)
  if (!_internal_has_payload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.payload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ClientHello::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ClientHello.payload)
}

// -------------------------------------------------------------------

// HandshakeMessage_ServerHello

// optional bytes ephemeral = 1;
inline bool HandshakeMessage_ServerHello::_internal_has_ephemeral() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HandshakeMessage_ServerHello::has_ephemeral() const {
  return _internal_has_ephemeral();
}
inline void HandshakeMessage_ServerHello::clear_ephemeral() {
  _impl_.ephemeral_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HandshakeMessage_ServerHello::ephemeral() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.ephemeral)
  return _internal_ephemeral();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ServerHello::set_ephemeral(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.ephemeral_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.ephemeral)
}
inline std::string* HandshakeMessage_ServerHello::mutable_ephemeral() {
  std::string* _s = _internal_mutable_ephemeral();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.ephemeral)
  return _s;
}
inline const std::string& HandshakeMessage_ServerHello::_internal_ephemeral() const {
  return _impl_.ephemeral_.Get();
}
inline void HandshakeMessage_ServerHello::_internal_set_ephemeral(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ephemeral_.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::_internal_mutable_ephemeral() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.ephemeral_.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::release_ephemeral() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.ephemeral)
  if (!_internal_has_ephemeral()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.ephemeral_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeral_.IsDefault()) {
    _impl_.ephemeral_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ServerHello::set_allocated_ephemeral(std::string* ephemeral) {
  if (ephemeral != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ephemeral_.SetAllocated(ephemeral, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ephemeral_.IsDefault()) {
    _impl_.ephemeral_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.ephemeral)
}

// optional bytes static = 2;
inline bool HandshakeMessage_ServerHello::_internal_has_static_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HandshakeMessage_ServerHello::has_static_() const {
  return _internal_has_static_();
}
inline void HandshakeMessage_ServerHello::clear_static_() {
  _impl_.static__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HandshakeMessage_ServerHello::static_() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.static)
  return _internal_static_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ServerHello::set_static_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.static__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.static)
}
inline std::string* HandshakeMessage_ServerHello::mutable_static_() {
  std::string* _s = _internal_mutable_static_();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.static)
  return _s;
}
inline const std::string& HandshakeMessage_ServerHello::_internal_static_() const {
  return _impl_.static__.Get();
}
inline void HandshakeMessage_ServerHello::_internal_set_static_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.static__.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::_internal_mutable_static_() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.static__.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::release_static_() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.static)
  if (!_internal_has_static_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.static__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ServerHello::set_allocated_static_(std::string* static_) {
  if (static_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.static__.SetAllocated(static_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.static__.IsDefault()) {
    _impl_.static__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.static)
}

// optional bytes payload = 3;
inline bool HandshakeMessage_ServerHello::_internal_has_payload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HandshakeMessage_ServerHello::has_payload() const {
  return _internal_has_payload();
}
inline void HandshakeMessage_ServerHello::clear_payload() {
  _impl_.payload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& HandshakeMessage_ServerHello::payload() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.ServerHello.payload)
  return _internal_payload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HandshakeMessage_ServerHello::set_payload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.payload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HandshakeMessage.ServerHello.payload)
}
inline std::string* HandshakeMessage_ServerHello::mutable_payload() {
  std::string* _s = _internal_mutable_payload();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.ServerHello.payload)
  return _s;
}
inline const std::string& HandshakeMessage_ServerHello::_internal_payload() const {
  return _impl_.payload_.Get();
}
inline void HandshakeMessage_ServerHello::_internal_set_payload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.payload_.Set(value, GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::_internal_mutable_payload() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.payload_.Mutable(GetArenaForAllocation());
}
inline std::string* HandshakeMessage_ServerHello::release_payload() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.ServerHello.payload)
  if (!_internal_has_payload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.payload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HandshakeMessage_ServerHello::set_allocated_payload(std::string* payload) {
  if (payload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.payload_.SetAllocated(payload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.payload_.IsDefault()) {
    _impl_.payload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.ServerHello.payload)
}

// -------------------------------------------------------------------

// HandshakeMessage

// optional .proto.HandshakeMessage.ClientHello clientHello = 2;
inline bool HandshakeMessage::_internal_has_clienthello() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.clienthello_ != nullptr);
  return value;
}
inline bool HandshakeMessage::has_clienthello() const {
  return _internal_has_clienthello();
}
inline void HandshakeMessage::clear_clienthello() {
  if (_impl_.clienthello_ != nullptr) _impl_.clienthello_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::_internal_clienthello() const {
  const ::proto::HandshakeMessage_ClientHello* p = _impl_.clienthello_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ClientHello&>(
      ::proto::_HandshakeMessage_ClientHello_default_instance_);
}
inline const ::proto::HandshakeMessage_ClientHello& HandshakeMessage::clienthello() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientHello)
  return _internal_clienthello();
}
inline void HandshakeMessage::unsafe_arena_set_allocated_clienthello(
    ::proto::HandshakeMessage_ClientHello* clienthello) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clienthello_);
  }
  _impl_.clienthello_ = clienthello;
  if (clienthello) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientHello)
}
inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::release_clienthello() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_;
  _impl_.clienthello_ = 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 ::proto::HandshakeMessage_ClientHello* HandshakeMessage::unsafe_arena_release_clienthello() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientHello)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::HandshakeMessage_ClientHello* temp = _impl_.clienthello_;
  _impl_.clienthello_ = nullptr;
  return temp;
}
inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::_internal_mutable_clienthello() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.clienthello_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientHello>(GetArenaForAllocation());
    _impl_.clienthello_ = p;
  }
  return _impl_.clienthello_;
}
inline ::proto::HandshakeMessage_ClientHello* HandshakeMessage::mutable_clienthello() {
  ::proto::HandshakeMessage_ClientHello* _msg = _internal_mutable_clienthello();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientHello)
  return _msg;
}
inline void HandshakeMessage::set_allocated_clienthello(::proto::HandshakeMessage_ClientHello* clienthello) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.clienthello_;
  }
  if (clienthello) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clienthello);
    if (message_arena != submessage_arena) {
      clienthello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, clienthello, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.clienthello_ = clienthello;
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientHello)
}

// optional .proto.HandshakeMessage.ServerHello serverHello = 3;
inline bool HandshakeMessage::_internal_has_serverhello() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.serverhello_ != nullptr);
  return value;
}
inline bool HandshakeMessage::has_serverhello() const {
  return _internal_has_serverhello();
}
inline void HandshakeMessage::clear_serverhello() {
  if (_impl_.serverhello_ != nullptr) _impl_.serverhello_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::_internal_serverhello() const {
  const ::proto::HandshakeMessage_ServerHello* p = _impl_.serverhello_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ServerHello&>(
      ::proto::_HandshakeMessage_ServerHello_default_instance_);
}
inline const ::proto::HandshakeMessage_ServerHello& HandshakeMessage::serverhello() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.serverHello)
  return _internal_serverhello();
}
inline void HandshakeMessage::unsafe_arena_set_allocated_serverhello(
    ::proto::HandshakeMessage_ServerHello* serverhello) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serverhello_);
  }
  _impl_.serverhello_ = serverhello;
  if (serverhello) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.serverHello)
}
inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::release_serverhello() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_;
  _impl_.serverhello_ = 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 ::proto::HandshakeMessage_ServerHello* HandshakeMessage::unsafe_arena_release_serverhello() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.serverHello)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::HandshakeMessage_ServerHello* temp = _impl_.serverhello_;
  _impl_.serverhello_ = nullptr;
  return temp;
}
inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::_internal_mutable_serverhello() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.serverhello_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ServerHello>(GetArenaForAllocation());
    _impl_.serverhello_ = p;
  }
  return _impl_.serverhello_;
}
inline ::proto::HandshakeMessage_ServerHello* HandshakeMessage::mutable_serverhello() {
  ::proto::HandshakeMessage_ServerHello* _msg = _internal_mutable_serverhello();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.serverHello)
  return _msg;
}
inline void HandshakeMessage::set_allocated_serverhello(::proto::HandshakeMessage_ServerHello* serverhello) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.serverhello_;
  }
  if (serverhello) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(serverhello);
    if (message_arena != submessage_arena) {
      serverhello = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, serverhello, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.serverhello_ = serverhello;
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.serverHello)
}

// optional .proto.HandshakeMessage.ClientFinish clientFinish = 4;
inline bool HandshakeMessage::_internal_has_clientfinish() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.clientfinish_ != nullptr);
  return value;
}
inline bool HandshakeMessage::has_clientfinish() const {
  return _internal_has_clientfinish();
}
inline void HandshakeMessage::clear_clientfinish() {
  if (_impl_.clientfinish_ != nullptr) _impl_.clientfinish_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::_internal_clientfinish() const {
  const ::proto::HandshakeMessage_ClientFinish* p = _impl_.clientfinish_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::HandshakeMessage_ClientFinish&>(
      ::proto::_HandshakeMessage_ClientFinish_default_instance_);
}
inline const ::proto::HandshakeMessage_ClientFinish& HandshakeMessage::clientfinish() const {
  // @@protoc_insertion_point(field_get:proto.HandshakeMessage.clientFinish)
  return _internal_clientfinish();
}
inline void HandshakeMessage::unsafe_arena_set_allocated_clientfinish(
    ::proto::HandshakeMessage_ClientFinish* clientfinish) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clientfinish_);
  }
  _impl_.clientfinish_ = clientfinish;
  if (clientfinish) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HandshakeMessage.clientFinish)
}
inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::release_clientfinish() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_;
  _impl_.clientfinish_ = 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 ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::unsafe_arena_release_clientfinish() {
  // @@protoc_insertion_point(field_release:proto.HandshakeMessage.clientFinish)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::HandshakeMessage_ClientFinish* temp = _impl_.clientfinish_;
  _impl_.clientfinish_ = nullptr;
  return temp;
}
inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::_internal_mutable_clientfinish() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.clientfinish_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::HandshakeMessage_ClientFinish>(GetArenaForAllocation());
    _impl_.clientfinish_ = p;
  }
  return _impl_.clientfinish_;
}
inline ::proto::HandshakeMessage_ClientFinish* HandshakeMessage::mutable_clientfinish() {
  ::proto::HandshakeMessage_ClientFinish* _msg = _internal_mutable_clientfinish();
  // @@protoc_insertion_point(field_mutable:proto.HandshakeMessage.clientFinish)
  return _msg;
}
inline void HandshakeMessage::set_allocated_clientfinish(::proto::HandshakeMessage_ClientFinish* clientfinish) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.clientfinish_;
  }
  if (clientfinish) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clientfinish);
    if (message_arena != submessage_arena) {
      clientfinish = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, clientfinish, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.clientfinish_ = clientfinish;
  // @@protoc_insertion_point(field_set_allocated:proto.HandshakeMessage.clientFinish)
}

// -------------------------------------------------------------------

// HistorySync

// required .proto.HistorySync.HistorySyncType syncType = 1;
inline bool HistorySync::_internal_has_synctype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool HistorySync::has_synctype() const {
  return _internal_has_synctype();
}
inline void HistorySync::clear_synctype() {
  _impl_.synctype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::HistorySync_HistorySyncType HistorySync::_internal_synctype() const {
  return static_cast< ::proto::HistorySync_HistorySyncType >(_impl_.synctype_);
}
inline ::proto::HistorySync_HistorySyncType HistorySync::synctype() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.syncType)
  return _internal_synctype();
}
inline void HistorySync::_internal_set_synctype(::proto::HistorySync_HistorySyncType value) {
  assert(::proto::HistorySync_HistorySyncType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.synctype_ = value;
}
inline void HistorySync::set_synctype(::proto::HistorySync_HistorySyncType value) {
  _internal_set_synctype(value);
  // @@protoc_insertion_point(field_set:proto.HistorySync.syncType)
}

// repeated .proto.Conversation conversations = 2;
inline int HistorySync::_internal_conversations_size() const {
  return _impl_.conversations_.size();
}
inline int HistorySync::conversations_size() const {
  return _internal_conversations_size();
}
inline void HistorySync::clear_conversations() {
  _impl_.conversations_.Clear();
}
inline ::proto::Conversation* HistorySync::mutable_conversations(int index) {
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.conversations)
  return _impl_.conversations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >*
HistorySync::mutable_conversations() {
  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.conversations)
  return &_impl_.conversations_;
}
inline const ::proto::Conversation& HistorySync::_internal_conversations(int index) const {
  return _impl_.conversations_.Get(index);
}
inline const ::proto::Conversation& HistorySync::conversations(int index) const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.conversations)
  return _internal_conversations(index);
}
inline ::proto::Conversation* HistorySync::_internal_add_conversations() {
  return _impl_.conversations_.Add();
}
inline ::proto::Conversation* HistorySync::add_conversations() {
  ::proto::Conversation* _add = _internal_add_conversations();
  // @@protoc_insertion_point(field_add:proto.HistorySync.conversations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Conversation >&
HistorySync::conversations() const {
  // @@protoc_insertion_point(field_list:proto.HistorySync.conversations)
  return _impl_.conversations_;
}

// repeated .proto.WebMessageInfo statusV3Messages = 3;
inline int HistorySync::_internal_statusv3messages_size() const {
  return _impl_.statusv3messages_.size();
}
inline int HistorySync::statusv3messages_size() const {
  return _internal_statusv3messages_size();
}
inline void HistorySync::clear_statusv3messages() {
  _impl_.statusv3messages_.Clear();
}
inline ::proto::WebMessageInfo* HistorySync::mutable_statusv3messages(int index) {
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.statusV3Messages)
  return _impl_.statusv3messages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
HistorySync::mutable_statusv3messages() {
  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.statusV3Messages)
  return &_impl_.statusv3messages_;
}
inline const ::proto::WebMessageInfo& HistorySync::_internal_statusv3messages(int index) const {
  return _impl_.statusv3messages_.Get(index);
}
inline const ::proto::WebMessageInfo& HistorySync::statusv3messages(int index) const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.statusV3Messages)
  return _internal_statusv3messages(index);
}
inline ::proto::WebMessageInfo* HistorySync::_internal_add_statusv3messages() {
  return _impl_.statusv3messages_.Add();
}
inline ::proto::WebMessageInfo* HistorySync::add_statusv3messages() {
  ::proto::WebMessageInfo* _add = _internal_add_statusv3messages();
  // @@protoc_insertion_point(field_add:proto.HistorySync.statusV3Messages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
HistorySync::statusv3messages() const {
  // @@protoc_insertion_point(field_list:proto.HistorySync.statusV3Messages)
  return _impl_.statusv3messages_;
}

// optional uint32 chunkOrder = 5;
inline bool HistorySync::_internal_has_chunkorder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool HistorySync::has_chunkorder() const {
  return _internal_has_chunkorder();
}
inline void HistorySync::clear_chunkorder() {
  _impl_.chunkorder_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t HistorySync::_internal_chunkorder() const {
  return _impl_.chunkorder_;
}
inline uint32_t HistorySync::chunkorder() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.chunkOrder)
  return _internal_chunkorder();
}
inline void HistorySync::_internal_set_chunkorder(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.chunkorder_ = value;
}
inline void HistorySync::set_chunkorder(uint32_t value) {
  _internal_set_chunkorder(value);
  // @@protoc_insertion_point(field_set:proto.HistorySync.chunkOrder)
}

// optional uint32 progress = 6;
inline bool HistorySync::_internal_has_progress() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool HistorySync::has_progress() const {
  return _internal_has_progress();
}
inline void HistorySync::clear_progress() {
  _impl_.progress_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t HistorySync::_internal_progress() const {
  return _impl_.progress_;
}
inline uint32_t HistorySync::progress() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.progress)
  return _internal_progress();
}
inline void HistorySync::_internal_set_progress(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.progress_ = value;
}
inline void HistorySync::set_progress(uint32_t value) {
  _internal_set_progress(value);
  // @@protoc_insertion_point(field_set:proto.HistorySync.progress)
}

// repeated .proto.Pushname pushnames = 7;
inline int HistorySync::_internal_pushnames_size() const {
  return _impl_.pushnames_.size();
}
inline int HistorySync::pushnames_size() const {
  return _internal_pushnames_size();
}
inline void HistorySync::clear_pushnames() {
  _impl_.pushnames_.Clear();
}
inline ::proto::Pushname* HistorySync::mutable_pushnames(int index) {
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.pushnames)
  return _impl_.pushnames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >*
HistorySync::mutable_pushnames() {
  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pushnames)
  return &_impl_.pushnames_;
}
inline const ::proto::Pushname& HistorySync::_internal_pushnames(int index) const {
  return _impl_.pushnames_.Get(index);
}
inline const ::proto::Pushname& HistorySync::pushnames(int index) const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.pushnames)
  return _internal_pushnames(index);
}
inline ::proto::Pushname* HistorySync::_internal_add_pushnames() {
  return _impl_.pushnames_.Add();
}
inline ::proto::Pushname* HistorySync::add_pushnames() {
  ::proto::Pushname* _add = _internal_add_pushnames();
  // @@protoc_insertion_point(field_add:proto.HistorySync.pushnames)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Pushname >&
HistorySync::pushnames() const {
  // @@protoc_insertion_point(field_list:proto.HistorySync.pushnames)
  return _impl_.pushnames_;
}

// optional .proto.GlobalSettings globalSettings = 8;
inline bool HistorySync::_internal_has_globalsettings() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.globalsettings_ != nullptr);
  return value;
}
inline bool HistorySync::has_globalsettings() const {
  return _internal_has_globalsettings();
}
inline void HistorySync::clear_globalsettings() {
  if (_impl_.globalsettings_ != nullptr) _impl_.globalsettings_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::GlobalSettings& HistorySync::_internal_globalsettings() const {
  const ::proto::GlobalSettings* p = _impl_.globalsettings_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::GlobalSettings&>(
      ::proto::_GlobalSettings_default_instance_);
}
inline const ::proto::GlobalSettings& HistorySync::globalsettings() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.globalSettings)
  return _internal_globalsettings();
}
inline void HistorySync::unsafe_arena_set_allocated_globalsettings(
    ::proto::GlobalSettings* globalsettings) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.globalsettings_);
  }
  _impl_.globalsettings_ = globalsettings;
  if (globalsettings) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySync.globalSettings)
}
inline ::proto::GlobalSettings* HistorySync::release_globalsettings() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::GlobalSettings* temp = _impl_.globalsettings_;
  _impl_.globalsettings_ = 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 ::proto::GlobalSettings* HistorySync::unsafe_arena_release_globalsettings() {
  // @@protoc_insertion_point(field_release:proto.HistorySync.globalSettings)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::GlobalSettings* temp = _impl_.globalsettings_;
  _impl_.globalsettings_ = nullptr;
  return temp;
}
inline ::proto::GlobalSettings* HistorySync::_internal_mutable_globalsettings() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.globalsettings_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::GlobalSettings>(GetArenaForAllocation());
    _impl_.globalsettings_ = p;
  }
  return _impl_.globalsettings_;
}
inline ::proto::GlobalSettings* HistorySync::mutable_globalsettings() {
  ::proto::GlobalSettings* _msg = _internal_mutable_globalsettings();
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.globalSettings)
  return _msg;
}
inline void HistorySync::set_allocated_globalsettings(::proto::GlobalSettings* globalsettings) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.globalsettings_;
  }
  if (globalsettings) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(globalsettings);
    if (message_arena != submessage_arena) {
      globalsettings = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, globalsettings, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.globalsettings_ = globalsettings;
  // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.globalSettings)
}

// optional bytes threadIdUserSecret = 9;
inline bool HistorySync::_internal_has_threadidusersecret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HistorySync::has_threadidusersecret() const {
  return _internal_has_threadidusersecret();
}
inline void HistorySync::clear_threadidusersecret() {
  _impl_.threadidusersecret_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HistorySync::threadidusersecret() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.threadIdUserSecret)
  return _internal_threadidusersecret();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HistorySync::set_threadidusersecret(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.threadidusersecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HistorySync.threadIdUserSecret)
}
inline std::string* HistorySync::mutable_threadidusersecret() {
  std::string* _s = _internal_mutable_threadidusersecret();
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.threadIdUserSecret)
  return _s;
}
inline const std::string& HistorySync::_internal_threadidusersecret() const {
  return _impl_.threadidusersecret_.Get();
}
inline void HistorySync::_internal_set_threadidusersecret(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.threadidusersecret_.Set(value, GetArenaForAllocation());
}
inline std::string* HistorySync::_internal_mutable_threadidusersecret() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.threadidusersecret_.Mutable(GetArenaForAllocation());
}
inline std::string* HistorySync::release_threadidusersecret() {
  // @@protoc_insertion_point(field_release:proto.HistorySync.threadIdUserSecret)
  if (!_internal_has_threadidusersecret()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.threadidusersecret_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.threadidusersecret_.IsDefault()) {
    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HistorySync::set_allocated_threadidusersecret(std::string* threadidusersecret) {
  if (threadidusersecret != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.threadidusersecret_.SetAllocated(threadidusersecret, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.threadidusersecret_.IsDefault()) {
    _impl_.threadidusersecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HistorySync.threadIdUserSecret)
}

// optional uint32 threadDsTimeframeOffset = 10;
inline bool HistorySync::_internal_has_threaddstimeframeoffset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool HistorySync::has_threaddstimeframeoffset() const {
  return _internal_has_threaddstimeframeoffset();
}
inline void HistorySync::clear_threaddstimeframeoffset() {
  _impl_.threaddstimeframeoffset_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t HistorySync::_internal_threaddstimeframeoffset() const {
  return _impl_.threaddstimeframeoffset_;
}
inline uint32_t HistorySync::threaddstimeframeoffset() const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.threadDsTimeframeOffset)
  return _internal_threaddstimeframeoffset();
}
inline void HistorySync::_internal_set_threaddstimeframeoffset(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.threaddstimeframeoffset_ = value;
}
inline void HistorySync::set_threaddstimeframeoffset(uint32_t value) {
  _internal_set_threaddstimeframeoffset(value);
  // @@protoc_insertion_point(field_set:proto.HistorySync.threadDsTimeframeOffset)
}

// repeated .proto.StickerMetadata recentStickers = 11;
inline int HistorySync::_internal_recentstickers_size() const {
  return _impl_.recentstickers_.size();
}
inline int HistorySync::recentstickers_size() const {
  return _internal_recentstickers_size();
}
inline void HistorySync::clear_recentstickers() {
  _impl_.recentstickers_.Clear();
}
inline ::proto::StickerMetadata* HistorySync::mutable_recentstickers(int index) {
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.recentStickers)
  return _impl_.recentstickers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >*
HistorySync::mutable_recentstickers() {
  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.recentStickers)
  return &_impl_.recentstickers_;
}
inline const ::proto::StickerMetadata& HistorySync::_internal_recentstickers(int index) const {
  return _impl_.recentstickers_.Get(index);
}
inline const ::proto::StickerMetadata& HistorySync::recentstickers(int index) const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.recentStickers)
  return _internal_recentstickers(index);
}
inline ::proto::StickerMetadata* HistorySync::_internal_add_recentstickers() {
  return _impl_.recentstickers_.Add();
}
inline ::proto::StickerMetadata* HistorySync::add_recentstickers() {
  ::proto::StickerMetadata* _add = _internal_add_recentstickers();
  // @@protoc_insertion_point(field_add:proto.HistorySync.recentStickers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::StickerMetadata >&
HistorySync::recentstickers() const {
  // @@protoc_insertion_point(field_list:proto.HistorySync.recentStickers)
  return _impl_.recentstickers_;
}

// repeated .proto.PastParticipants pastParticipants = 12;
inline int HistorySync::_internal_pastparticipants_size() const {
  return _impl_.pastparticipants_.size();
}
inline int HistorySync::pastparticipants_size() const {
  return _internal_pastparticipants_size();
}
inline void HistorySync::clear_pastparticipants() {
  _impl_.pastparticipants_.Clear();
}
inline ::proto::PastParticipants* HistorySync::mutable_pastparticipants(int index) {
  // @@protoc_insertion_point(field_mutable:proto.HistorySync.pastParticipants)
  return _impl_.pastparticipants_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >*
HistorySync::mutable_pastparticipants() {
  // @@protoc_insertion_point(field_mutable_list:proto.HistorySync.pastParticipants)
  return &_impl_.pastparticipants_;
}
inline const ::proto::PastParticipants& HistorySync::_internal_pastparticipants(int index) const {
  return _impl_.pastparticipants_.Get(index);
}
inline const ::proto::PastParticipants& HistorySync::pastparticipants(int index) const {
  // @@protoc_insertion_point(field_get:proto.HistorySync.pastParticipants)
  return _internal_pastparticipants(index);
}
inline ::proto::PastParticipants* HistorySync::_internal_add_pastparticipants() {
  return _impl_.pastparticipants_.Add();
}
inline ::proto::PastParticipants* HistorySync::add_pastparticipants() {
  ::proto::PastParticipants* _add = _internal_add_pastparticipants();
  // @@protoc_insertion_point(field_add:proto.HistorySync.pastParticipants)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipants >&
HistorySync::pastparticipants() const {
  // @@protoc_insertion_point(field_list:proto.HistorySync.pastParticipants)
  return _impl_.pastparticipants_;
}

// -------------------------------------------------------------------

// HistorySyncMsg

// optional .proto.WebMessageInfo message = 1;
inline bool HistorySyncMsg::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
  return value;
}
inline bool HistorySyncMsg::has_message() const {
  return _internal_has_message();
}
inline void HistorySyncMsg::clear_message() {
  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::WebMessageInfo& HistorySyncMsg::_internal_message() const {
  const ::proto::WebMessageInfo* p = _impl_.message_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::WebMessageInfo&>(
      ::proto::_WebMessageInfo_default_instance_);
}
inline const ::proto::WebMessageInfo& HistorySyncMsg::message() const {
  // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.message)
  return _internal_message();
}
inline void HistorySyncMsg::unsafe_arena_set_allocated_message(
    ::proto::WebMessageInfo* message) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
  }
  _impl_.message_ = message;
  if (message) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HistorySyncMsg.message)
}
inline ::proto::WebMessageInfo* HistorySyncMsg::release_message() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::WebMessageInfo* temp = _impl_.message_;
  _impl_.message_ = 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 ::proto::WebMessageInfo* HistorySyncMsg::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_release:proto.HistorySyncMsg.message)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::WebMessageInfo* temp = _impl_.message_;
  _impl_.message_ = nullptr;
  return temp;
}
inline ::proto::WebMessageInfo* HistorySyncMsg::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.message_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::WebMessageInfo>(GetArenaForAllocation());
    _impl_.message_ = p;
  }
  return _impl_.message_;
}
inline ::proto::WebMessageInfo* HistorySyncMsg::mutable_message() {
  ::proto::WebMessageInfo* _msg = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.HistorySyncMsg.message)
  return _msg;
}
inline void HistorySyncMsg::set_allocated_message(::proto::WebMessageInfo* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.message_ = message;
  // @@protoc_insertion_point(field_set_allocated:proto.HistorySyncMsg.message)
}

// optional uint64 msgOrderId = 2;
inline bool HistorySyncMsg::_internal_has_msgorderid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HistorySyncMsg::has_msgorderid() const {
  return _internal_has_msgorderid();
}
inline void HistorySyncMsg::clear_msgorderid() {
  _impl_.msgorderid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t HistorySyncMsg::_internal_msgorderid() const {
  return _impl_.msgorderid_;
}
inline uint64_t HistorySyncMsg::msgorderid() const {
  // @@protoc_insertion_point(field_get:proto.HistorySyncMsg.msgOrderId)
  return _internal_msgorderid();
}
inline void HistorySyncMsg::_internal_set_msgorderid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.msgorderid_ = value;
}
inline void HistorySyncMsg::set_msgorderid(uint64_t value) {
  _internal_set_msgorderid(value);
  // @@protoc_insertion_point(field_set:proto.HistorySyncMsg.msgOrderId)
}

// -------------------------------------------------------------------

// HydratedTemplateButton_HydratedCallButton

// optional string displayText = 1;
inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedCallButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void HydratedTemplateButton_HydratedCallButton::clear_displaytext() {
  _impl_.displaytext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HydratedTemplateButton_HydratedCallButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.displayText)
  return _internal_displaytext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedCallButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.displayText)
}
inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_displaytext() {
  std::string* _s = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.displayText)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_displaytext() const {
  return _impl_.displaytext_.Get();
}
inline void HydratedTemplateButton_HydratedCallButton::_internal_set_displaytext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedCallButton::release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.displayText)
  if (!_internal_has_displaytext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.displaytext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HydratedTemplateButton_HydratedCallButton::set_allocated_displaytext(std::string* displaytext) {
  if (displaytext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.displayText)
}

// optional string phoneNumber = 2;
inline bool HydratedTemplateButton_HydratedCallButton::_internal_has_phonenumber() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedCallButton::has_phonenumber() const {
  return _internal_has_phonenumber();
}
inline void HydratedTemplateButton_HydratedCallButton::clear_phonenumber() {
  _impl_.phonenumber_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HydratedTemplateButton_HydratedCallButton::phonenumber() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
  return _internal_phonenumber();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedCallButton::set_phonenumber(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.phonenumber_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
}
inline std::string* HydratedTemplateButton_HydratedCallButton::mutable_phonenumber() {
  std::string* _s = _internal_mutable_phonenumber();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedCallButton::_internal_phonenumber() const {
  return _impl_.phonenumber_.Get();
}
inline void HydratedTemplateButton_HydratedCallButton::_internal_set_phonenumber(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.phonenumber_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedCallButton::_internal_mutable_phonenumber() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.phonenumber_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedCallButton::release_phonenumber() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
  if (!_internal_has_phonenumber()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.phonenumber_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phonenumber_.IsDefault()) {
    _impl_.phonenumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HydratedTemplateButton_HydratedCallButton::set_allocated_phonenumber(std::string* phonenumber) {
  if (phonenumber != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.phonenumber_.SetAllocated(phonenumber, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phonenumber_.IsDefault()) {
    _impl_.phonenumber_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedCallButton.phoneNumber)
}

// -------------------------------------------------------------------

// HydratedTemplateButton_HydratedQuickReplyButton

// optional string displayText = 1;
inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_displaytext() {
  _impl_.displaytext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
  return _internal_displaytext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedQuickReplyButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_displaytext() {
  std::string* _s = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_displaytext() const {
  return _impl_.displaytext_.Get();
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_displaytext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
  if (!_internal_has_displaytext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.displaytext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_displaytext(std::string* displaytext) {
  if (displaytext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.displayText)
}

// optional string id = 2;
inline bool HydratedTemplateButton_HydratedQuickReplyButton::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedQuickReplyButton::has_id() const {
  return _internal_has_id();
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::id() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedQuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedQuickReplyButton::_internal_id() const {
  return _impl_.id_.Get();
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedQuickReplyButton::release_id() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HydratedTemplateButton_HydratedQuickReplyButton::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedQuickReplyButton.id)
}

// -------------------------------------------------------------------

// HydratedTemplateButton_HydratedURLButton

// optional string displayText = 1;
inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedURLButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void HydratedTemplateButton_HydratedURLButton::clear_displaytext() {
  _impl_.displaytext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& HydratedTemplateButton_HydratedURLButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.displayText)
  return _internal_displaytext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedURLButton::set_displaytext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.displayText)
}
inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_displaytext() {
  std::string* _s = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.displayText)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_displaytext() const {
  return _impl_.displaytext_.Get();
}
inline void HydratedTemplateButton_HydratedURLButton::_internal_set_displaytext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedURLButton::release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.displayText)
  if (!_internal_has_displaytext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.displaytext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void HydratedTemplateButton_HydratedURLButton::set_allocated_displaytext(std::string* displaytext) {
  if (displaytext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.HydratedTemplateButton.HydratedURLButton.displayText)
}

// optional string url = 2;
inline bool HydratedTemplateButton_HydratedURLButton::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool HydratedTemplateButton_HydratedURLButton::has_url() const {
  return _internal_has_url();
}
inline void HydratedTemplateButton_HydratedURLButton::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& HydratedTemplateButton_HydratedURLButton::url() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.HydratedURLButton.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HydratedTemplateButton_HydratedURLButton::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.HydratedURLButton.url)
}
inline std::string* HydratedTemplateButton_HydratedURLButton::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.HydratedURLButton.url)
  return _s;
}
inline const std::string& HydratedTemplateButton_HydratedURLButton::_internal_url() const {
  return _impl_.url_.Get();
}
inline void HydratedTemplateButton_HydratedURLButton::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedURLButton::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* HydratedTemplateButton_HydratedURLButton::release_url() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.HydratedURLButton.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 HydratedTemplateButton_HydratedURLButton::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:proto.HydratedTemplateButton.HydratedURLButton.url)
}

// -------------------------------------------------------------------

// HydratedTemplateButton

// optional uint32 index = 4;
inline bool HydratedTemplateButton::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool HydratedTemplateButton::has_index() const {
  return _internal_has_index();
}
inline void HydratedTemplateButton::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t HydratedTemplateButton::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t HydratedTemplateButton::index() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.index)
  return _internal_index();
}
inline void HydratedTemplateButton::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.index_ = value;
}
inline void HydratedTemplateButton::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:proto.HydratedTemplateButton.index)
}

// .proto.HydratedTemplateButton.HydratedQuickReplyButton quickReplyButton = 1;
inline bool HydratedTemplateButton::_internal_has_quickreplybutton() const {
  return hydratedButton_case() == kQuickReplyButton;
}
inline bool HydratedTemplateButton::has_quickreplybutton() const {
  return _internal_has_quickreplybutton();
}
inline void HydratedTemplateButton::set_has_quickreplybutton() {
  _impl_._oneof_case_[0] = kQuickReplyButton;
}
inline void HydratedTemplateButton::clear_quickreplybutton() {
  if (_internal_has_quickreplybutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.hydratedButton_.quickreplybutton_;
    }
    clear_has_hydratedButton();
  }
}
inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::release_quickreplybutton() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.quickReplyButton)
  if (_internal_has_quickreplybutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.hydratedButton_.quickreplybutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::_internal_quickreplybutton() const {
  return _internal_has_quickreplybutton()
      ? *_impl_.hydratedButton_.quickreplybutton_
      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedQuickReplyButton&>(::proto::_HydratedTemplateButton_HydratedQuickReplyButton_default_instance_);
}
inline const ::proto::HydratedTemplateButton_HydratedQuickReplyButton& HydratedTemplateButton::quickreplybutton() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.quickReplyButton)
  return _internal_quickreplybutton();
}
inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::unsafe_arena_release_quickreplybutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.quickReplyButton)
  if (_internal_has_quickreplybutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedQuickReplyButton* temp = _impl_.hydratedButton_.quickreplybutton_;
    _impl_.hydratedButton_.quickreplybutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HydratedTemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::HydratedTemplateButton_HydratedQuickReplyButton* quickreplybutton) {
  clear_hydratedButton();
  if (quickreplybutton) {
    set_has_quickreplybutton();
    _impl_.hydratedButton_.quickreplybutton_ = quickreplybutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.quickReplyButton)
}
inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::_internal_mutable_quickreplybutton() {
  if (!_internal_has_quickreplybutton()) {
    clear_hydratedButton();
    set_has_quickreplybutton();
    _impl_.hydratedButton_.quickreplybutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedQuickReplyButton >(GetArenaForAllocation());
  }
  return _impl_.hydratedButton_.quickreplybutton_;
}
inline ::proto::HydratedTemplateButton_HydratedQuickReplyButton* HydratedTemplateButton::mutable_quickreplybutton() {
  ::proto::HydratedTemplateButton_HydratedQuickReplyButton* _msg = _internal_mutable_quickreplybutton();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.quickReplyButton)
  return _msg;
}

// .proto.HydratedTemplateButton.HydratedURLButton urlButton = 2;
inline bool HydratedTemplateButton::_internal_has_urlbutton() const {
  return hydratedButton_case() == kUrlButton;
}
inline bool HydratedTemplateButton::has_urlbutton() const {
  return _internal_has_urlbutton();
}
inline void HydratedTemplateButton::set_has_urlbutton() {
  _impl_._oneof_case_[0] = kUrlButton;
}
inline void HydratedTemplateButton::clear_urlbutton() {
  if (_internal_has_urlbutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.hydratedButton_.urlbutton_;
    }
    clear_has_hydratedButton();
  }
}
inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::release_urlbutton() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.urlButton)
  if (_internal_has_urlbutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.hydratedButton_.urlbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::_internal_urlbutton() const {
  return _internal_has_urlbutton()
      ? *_impl_.hydratedButton_.urlbutton_
      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedURLButton&>(::proto::_HydratedTemplateButton_HydratedURLButton_default_instance_);
}
inline const ::proto::HydratedTemplateButton_HydratedURLButton& HydratedTemplateButton::urlbutton() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.urlButton)
  return _internal_urlbutton();
}
inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::unsafe_arena_release_urlbutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.urlButton)
  if (_internal_has_urlbutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedURLButton* temp = _impl_.hydratedButton_.urlbutton_;
    _impl_.hydratedButton_.urlbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HydratedTemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::HydratedTemplateButton_HydratedURLButton* urlbutton) {
  clear_hydratedButton();
  if (urlbutton) {
    set_has_urlbutton();
    _impl_.hydratedButton_.urlbutton_ = urlbutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.urlButton)
}
inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::_internal_mutable_urlbutton() {
  if (!_internal_has_urlbutton()) {
    clear_hydratedButton();
    set_has_urlbutton();
    _impl_.hydratedButton_.urlbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedURLButton >(GetArenaForAllocation());
  }
  return _impl_.hydratedButton_.urlbutton_;
}
inline ::proto::HydratedTemplateButton_HydratedURLButton* HydratedTemplateButton::mutable_urlbutton() {
  ::proto::HydratedTemplateButton_HydratedURLButton* _msg = _internal_mutable_urlbutton();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.urlButton)
  return _msg;
}

// .proto.HydratedTemplateButton.HydratedCallButton callButton = 3;
inline bool HydratedTemplateButton::_internal_has_callbutton() const {
  return hydratedButton_case() == kCallButton;
}
inline bool HydratedTemplateButton::has_callbutton() const {
  return _internal_has_callbutton();
}
inline void HydratedTemplateButton::set_has_callbutton() {
  _impl_._oneof_case_[0] = kCallButton;
}
inline void HydratedTemplateButton::clear_callbutton() {
  if (_internal_has_callbutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.hydratedButton_.callbutton_;
    }
    clear_has_hydratedButton();
  }
}
inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::release_callbutton() {
  // @@protoc_insertion_point(field_release:proto.HydratedTemplateButton.callButton)
  if (_internal_has_callbutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.hydratedButton_.callbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::_internal_callbutton() const {
  return _internal_has_callbutton()
      ? *_impl_.hydratedButton_.callbutton_
      : reinterpret_cast< ::proto::HydratedTemplateButton_HydratedCallButton&>(::proto::_HydratedTemplateButton_HydratedCallButton_default_instance_);
}
inline const ::proto::HydratedTemplateButton_HydratedCallButton& HydratedTemplateButton::callbutton() const {
  // @@protoc_insertion_point(field_get:proto.HydratedTemplateButton.callButton)
  return _internal_callbutton();
}
inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::unsafe_arena_release_callbutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.HydratedTemplateButton.callButton)
  if (_internal_has_callbutton()) {
    clear_has_hydratedButton();
    ::proto::HydratedTemplateButton_HydratedCallButton* temp = _impl_.hydratedButton_.callbutton_;
    _impl_.hydratedButton_.callbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void HydratedTemplateButton::unsafe_arena_set_allocated_callbutton(::proto::HydratedTemplateButton_HydratedCallButton* callbutton) {
  clear_hydratedButton();
  if (callbutton) {
    set_has_callbutton();
    _impl_.hydratedButton_.callbutton_ = callbutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.HydratedTemplateButton.callButton)
}
inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::_internal_mutable_callbutton() {
  if (!_internal_has_callbutton()) {
    clear_hydratedButton();
    set_has_callbutton();
    _impl_.hydratedButton_.callbutton_ = CreateMaybeMessage< ::proto::HydratedTemplateButton_HydratedCallButton >(GetArenaForAllocation());
  }
  return _impl_.hydratedButton_.callbutton_;
}
inline ::proto::HydratedTemplateButton_HydratedCallButton* HydratedTemplateButton::mutable_callbutton() {
  ::proto::HydratedTemplateButton_HydratedCallButton* _msg = _internal_mutable_callbutton();
  // @@protoc_insertion_point(field_mutable:proto.HydratedTemplateButton.callButton)
  return _msg;
}

inline bool HydratedTemplateButton::has_hydratedButton() const {
  return hydratedButton_case() != HYDRATEDBUTTON_NOT_SET;
}
inline void HydratedTemplateButton::clear_has_hydratedButton() {
  _impl_._oneof_case_[0] = HYDRATEDBUTTON_NOT_SET;
}
inline HydratedTemplateButton::HydratedButtonCase HydratedTemplateButton::hydratedButton_case() const {
  return HydratedTemplateButton::HydratedButtonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// IdentityKeyPairStructure

// optional bytes publicKey = 1;
inline bool IdentityKeyPairStructure::_internal_has_publickey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool IdentityKeyPairStructure::has_publickey() const {
  return _internal_has_publickey();
}
inline void IdentityKeyPairStructure::clear_publickey() {
  _impl_.publickey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IdentityKeyPairStructure::publickey() const {
  // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.publicKey)
  return _internal_publickey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IdentityKeyPairStructure::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:proto.IdentityKeyPairStructure.publicKey)
}
inline std::string* IdentityKeyPairStructure::mutable_publickey() {
  std::string* _s = _internal_mutable_publickey();
  // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.publicKey)
  return _s;
}
inline const std::string& IdentityKeyPairStructure::_internal_publickey() const {
  return _impl_.publickey_.Get();
}
inline void IdentityKeyPairStructure::_internal_set_publickey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.publickey_.Set(value, GetArenaForAllocation());
}
inline std::string* IdentityKeyPairStructure::_internal_mutable_publickey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.publickey_.Mutable(GetArenaForAllocation());
}
inline std::string* IdentityKeyPairStructure::release_publickey() {
  // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.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 IdentityKeyPairStructure::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:proto.IdentityKeyPairStructure.publicKey)
}

// optional bytes privateKey = 2;
inline bool IdentityKeyPairStructure::_internal_has_privatekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool IdentityKeyPairStructure::has_privatekey() const {
  return _internal_has_privatekey();
}
inline void IdentityKeyPairStructure::clear_privatekey() {
  _impl_.privatekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& IdentityKeyPairStructure::privatekey() const {
  // @@protoc_insertion_point(field_get:proto.IdentityKeyPairStructure.privateKey)
  return _internal_privatekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IdentityKeyPairStructure::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:proto.IdentityKeyPairStructure.privateKey)
}
inline std::string* IdentityKeyPairStructure::mutable_privatekey() {
  std::string* _s = _internal_mutable_privatekey();
  // @@protoc_insertion_point(field_mutable:proto.IdentityKeyPairStructure.privateKey)
  return _s;
}
inline const std::string& IdentityKeyPairStructure::_internal_privatekey() const {
  return _impl_.privatekey_.Get();
}
inline void IdentityKeyPairStructure::_internal_set_privatekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.privatekey_.Set(value, GetArenaForAllocation());
}
inline std::string* IdentityKeyPairStructure::_internal_mutable_privatekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
}
inline std::string* IdentityKeyPairStructure::release_privatekey() {
  // @@protoc_insertion_point(field_release:proto.IdentityKeyPairStructure.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 IdentityKeyPairStructure::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:proto.IdentityKeyPairStructure.privateKey)
}

// -------------------------------------------------------------------

// InteractiveAnnotation

// repeated .proto.Point polygonVertices = 1;
inline int InteractiveAnnotation::_internal_polygonvertices_size() const {
  return _impl_.polygonvertices_.size();
}
inline int InteractiveAnnotation::polygonvertices_size() const {
  return _internal_polygonvertices_size();
}
inline void InteractiveAnnotation::clear_polygonvertices() {
  _impl_.polygonvertices_.Clear();
}
inline ::proto::Point* InteractiveAnnotation::mutable_polygonvertices(int index) {
  // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.polygonVertices)
  return _impl_.polygonvertices_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >*
InteractiveAnnotation::mutable_polygonvertices() {
  // @@protoc_insertion_point(field_mutable_list:proto.InteractiveAnnotation.polygonVertices)
  return &_impl_.polygonvertices_;
}
inline const ::proto::Point& InteractiveAnnotation::_internal_polygonvertices(int index) const {
  return _impl_.polygonvertices_.Get(index);
}
inline const ::proto::Point& InteractiveAnnotation::polygonvertices(int index) const {
  // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.polygonVertices)
  return _internal_polygonvertices(index);
}
inline ::proto::Point* InteractiveAnnotation::_internal_add_polygonvertices() {
  return _impl_.polygonvertices_.Add();
}
inline ::proto::Point* InteractiveAnnotation::add_polygonvertices() {
  ::proto::Point* _add = _internal_add_polygonvertices();
  // @@protoc_insertion_point(field_add:proto.InteractiveAnnotation.polygonVertices)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Point >&
InteractiveAnnotation::polygonvertices() const {
  // @@protoc_insertion_point(field_list:proto.InteractiveAnnotation.polygonVertices)
  return _impl_.polygonvertices_;
}

// .proto.Location location = 2;
inline bool InteractiveAnnotation::_internal_has_location() const {
  return action_case() == kLocation;
}
inline bool InteractiveAnnotation::has_location() const {
  return _internal_has_location();
}
inline void InteractiveAnnotation::set_has_location() {
  _impl_._oneof_case_[0] = kLocation;
}
inline void InteractiveAnnotation::clear_location() {
  if (_internal_has_location()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.action_.location_;
    }
    clear_has_action();
  }
}
inline ::proto::Location* InteractiveAnnotation::release_location() {
  // @@protoc_insertion_point(field_release:proto.InteractiveAnnotation.location)
  if (_internal_has_location()) {
    clear_has_action();
    ::proto::Location* temp = _impl_.action_.location_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.action_.location_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Location& InteractiveAnnotation::_internal_location() const {
  return _internal_has_location()
      ? *_impl_.action_.location_
      : reinterpret_cast< ::proto::Location&>(::proto::_Location_default_instance_);
}
inline const ::proto::Location& InteractiveAnnotation::location() const {
  // @@protoc_insertion_point(field_get:proto.InteractiveAnnotation.location)
  return _internal_location();
}
inline ::proto::Location* InteractiveAnnotation::unsafe_arena_release_location() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.InteractiveAnnotation.location)
  if (_internal_has_location()) {
    clear_has_action();
    ::proto::Location* temp = _impl_.action_.location_;
    _impl_.action_.location_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void InteractiveAnnotation::unsafe_arena_set_allocated_location(::proto::Location* location) {
  clear_action();
  if (location) {
    set_has_location();
    _impl_.action_.location_ = location;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.InteractiveAnnotation.location)
}
inline ::proto::Location* InteractiveAnnotation::_internal_mutable_location() {
  if (!_internal_has_location()) {
    clear_action();
    set_has_location();
    _impl_.action_.location_ = CreateMaybeMessage< ::proto::Location >(GetArenaForAllocation());
  }
  return _impl_.action_.location_;
}
inline ::proto::Location* InteractiveAnnotation::mutable_location() {
  ::proto::Location* _msg = _internal_mutable_location();
  // @@protoc_insertion_point(field_mutable:proto.InteractiveAnnotation.location)
  return _msg;
}

inline bool InteractiveAnnotation::has_action() const {
  return action_case() != ACTION_NOT_SET;
}
inline void InteractiveAnnotation::clear_has_action() {
  _impl_._oneof_case_[0] = ACTION_NOT_SET;
}
inline InteractiveAnnotation::ActionCase InteractiveAnnotation::action_case() const {
  return InteractiveAnnotation::ActionCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// KeepInChat

// optional .proto.KeepType keepType = 1;
inline bool KeepInChat::_internal_has_keeptype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool KeepInChat::has_keeptype() const {
  return _internal_has_keeptype();
}
inline void KeepInChat::clear_keeptype() {
  _impl_.keeptype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::KeepType KeepInChat::_internal_keeptype() const {
  return static_cast< ::proto::KeepType >(_impl_.keeptype_);
}
inline ::proto::KeepType KeepInChat::keeptype() const {
  // @@protoc_insertion_point(field_get:proto.KeepInChat.keepType)
  return _internal_keeptype();
}
inline void KeepInChat::_internal_set_keeptype(::proto::KeepType value) {
  assert(::proto::KeepType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.keeptype_ = value;
}
inline void KeepInChat::set_keeptype(::proto::KeepType value) {
  _internal_set_keeptype(value);
  // @@protoc_insertion_point(field_set:proto.KeepInChat.keepType)
}

// optional int64 serverTimestamp = 2;
inline bool KeepInChat::_internal_has_servertimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool KeepInChat::has_servertimestamp() const {
  return _internal_has_servertimestamp();
}
inline void KeepInChat::clear_servertimestamp() {
  _impl_.servertimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t KeepInChat::_internal_servertimestamp() const {
  return _impl_.servertimestamp_;
}
inline int64_t KeepInChat::servertimestamp() const {
  // @@protoc_insertion_point(field_get:proto.KeepInChat.serverTimestamp)
  return _internal_servertimestamp();
}
inline void KeepInChat::_internal_set_servertimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.servertimestamp_ = value;
}
inline void KeepInChat::set_servertimestamp(int64_t value) {
  _internal_set_servertimestamp(value);
  // @@protoc_insertion_point(field_set:proto.KeepInChat.serverTimestamp)
}

// optional .proto.MessageKey key = 3;
inline bool KeepInChat::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool KeepInChat::has_key() const {
  return _internal_has_key();
}
inline void KeepInChat::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::MessageKey& KeepInChat::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& KeepInChat::key() const {
  // @@protoc_insertion_point(field_get:proto.KeepInChat.key)
  return _internal_key();
}
inline void KeepInChat::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.KeepInChat.key)
}
inline ::proto::MessageKey* KeepInChat::release_key() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* KeepInChat::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.KeepInChat.key)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* KeepInChat::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* KeepInChat::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.KeepInChat.key)
  return _msg;
}
inline void KeepInChat::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.key)
}

// optional string deviceJid = 4;
inline bool KeepInChat::_internal_has_devicejid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool KeepInChat::has_devicejid() const {
  return _internal_has_devicejid();
}
inline void KeepInChat::clear_devicejid() {
  _impl_.devicejid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& KeepInChat::devicejid() const {
  // @@protoc_insertion_point(field_get:proto.KeepInChat.deviceJid)
  return _internal_devicejid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeepInChat::set_devicejid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.devicejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.KeepInChat.deviceJid)
}
inline std::string* KeepInChat::mutable_devicejid() {
  std::string* _s = _internal_mutable_devicejid();
  // @@protoc_insertion_point(field_mutable:proto.KeepInChat.deviceJid)
  return _s;
}
inline const std::string& KeepInChat::_internal_devicejid() const {
  return _impl_.devicejid_.Get();
}
inline void KeepInChat::_internal_set_devicejid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.devicejid_.Set(value, GetArenaForAllocation());
}
inline std::string* KeepInChat::_internal_mutable_devicejid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.devicejid_.Mutable(GetArenaForAllocation());
}
inline std::string* KeepInChat::release_devicejid() {
  // @@protoc_insertion_point(field_release:proto.KeepInChat.deviceJid)
  if (!_internal_has_devicejid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.devicejid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.devicejid_.IsDefault()) {
    _impl_.devicejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void KeepInChat::set_allocated_devicejid(std::string* devicejid) {
  if (devicejid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.devicejid_.SetAllocated(devicejid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.devicejid_.IsDefault()) {
    _impl_.devicejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.KeepInChat.deviceJid)
}

// -------------------------------------------------------------------

// KeyId

// optional bytes id = 1;
inline bool KeyId::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool KeyId::has_id() const {
  return _internal_has_id();
}
inline void KeyId::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& KeyId::id() const {
  // @@protoc_insertion_point(field_get:proto.KeyId.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void KeyId::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.KeyId.id)
}
inline std::string* KeyId::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.KeyId.id)
  return _s;
}
inline const std::string& KeyId::_internal_id() const {
  return _impl_.id_.Get();
}
inline void KeyId::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* KeyId::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* KeyId::release_id() {
  // @@protoc_insertion_point(field_release:proto.KeyId.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void KeyId::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.KeyId.id)
}

// -------------------------------------------------------------------

// LocalizedName

// optional string lg = 1;
inline bool LocalizedName::_internal_has_lg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool LocalizedName::has_lg() const {
  return _internal_has_lg();
}
inline void LocalizedName::clear_lg() {
  _impl_.lg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& LocalizedName::lg() const {
  // @@protoc_insertion_point(field_get:proto.LocalizedName.lg)
  return _internal_lg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalizedName::set_lg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.lg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.LocalizedName.lg)
}
inline std::string* LocalizedName::mutable_lg() {
  std::string* _s = _internal_mutable_lg();
  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lg)
  return _s;
}
inline const std::string& LocalizedName::_internal_lg() const {
  return _impl_.lg_.Get();
}
inline void LocalizedName::_internal_set_lg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.lg_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalizedName::_internal_mutable_lg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.lg_.Mutable(GetArenaForAllocation());
}
inline std::string* LocalizedName::release_lg() {
  // @@protoc_insertion_point(field_release:proto.LocalizedName.lg)
  if (!_internal_has_lg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.lg_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lg_.IsDefault()) {
    _impl_.lg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LocalizedName::set_allocated_lg(std::string* lg) {
  if (lg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.lg_.SetAllocated(lg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lg_.IsDefault()) {
    _impl_.lg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lg)
}

// optional string lc = 2;
inline bool LocalizedName::_internal_has_lc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool LocalizedName::has_lc() const {
  return _internal_has_lc();
}
inline void LocalizedName::clear_lc() {
  _impl_.lc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& LocalizedName::lc() const {
  // @@protoc_insertion_point(field_get:proto.LocalizedName.lc)
  return _internal_lc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalizedName::set_lc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.lc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.LocalizedName.lc)
}
inline std::string* LocalizedName::mutable_lc() {
  std::string* _s = _internal_mutable_lc();
  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.lc)
  return _s;
}
inline const std::string& LocalizedName::_internal_lc() const {
  return _impl_.lc_.Get();
}
inline void LocalizedName::_internal_set_lc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.lc_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalizedName::_internal_mutable_lc() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.lc_.Mutable(GetArenaForAllocation());
}
inline std::string* LocalizedName::release_lc() {
  // @@protoc_insertion_point(field_release:proto.LocalizedName.lc)
  if (!_internal_has_lc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.lc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lc_.IsDefault()) {
    _impl_.lc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LocalizedName::set_allocated_lc(std::string* lc) {
  if (lc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.lc_.SetAllocated(lc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.lc_.IsDefault()) {
    _impl_.lc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.lc)
}

// optional string verifiedName = 3;
inline bool LocalizedName::_internal_has_verifiedname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool LocalizedName::has_verifiedname() const {
  return _internal_has_verifiedname();
}
inline void LocalizedName::clear_verifiedname() {
  _impl_.verifiedname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& LocalizedName::verifiedname() const {
  // @@protoc_insertion_point(field_get:proto.LocalizedName.verifiedName)
  return _internal_verifiedname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LocalizedName::set_verifiedname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.verifiedname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.LocalizedName.verifiedName)
}
inline std::string* LocalizedName::mutable_verifiedname() {
  std::string* _s = _internal_mutable_verifiedname();
  // @@protoc_insertion_point(field_mutable:proto.LocalizedName.verifiedName)
  return _s;
}
inline const std::string& LocalizedName::_internal_verifiedname() const {
  return _impl_.verifiedname_.Get();
}
inline void LocalizedName::_internal_set_verifiedname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.verifiedname_.Set(value, GetArenaForAllocation());
}
inline std::string* LocalizedName::_internal_mutable_verifiedname() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.verifiedname_.Mutable(GetArenaForAllocation());
}
inline std::string* LocalizedName::release_verifiedname() {
  // @@protoc_insertion_point(field_release:proto.LocalizedName.verifiedName)
  if (!_internal_has_verifiedname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.verifiedname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedname_.IsDefault()) {
    _impl_.verifiedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void LocalizedName::set_allocated_verifiedname(std::string* verifiedname) {
  if (verifiedname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedname_.IsDefault()) {
    _impl_.verifiedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.LocalizedName.verifiedName)
}

// -------------------------------------------------------------------

// Location

// optional double degreesLatitude = 1;
inline bool Location::_internal_has_degreeslatitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Location::has_degreeslatitude() const {
  return _internal_has_degreeslatitude();
}
inline void Location::clear_degreeslatitude() {
  _impl_.degreeslatitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline double Location::_internal_degreeslatitude() const {
  return _impl_.degreeslatitude_;
}
inline double Location::degreeslatitude() const {
  // @@protoc_insertion_point(field_get:proto.Location.degreesLatitude)
  return _internal_degreeslatitude();
}
inline void Location::_internal_set_degreeslatitude(double value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.degreeslatitude_ = value;
}
inline void Location::set_degreeslatitude(double value) {
  _internal_set_degreeslatitude(value);
  // @@protoc_insertion_point(field_set:proto.Location.degreesLatitude)
}

// optional double degreesLongitude = 2;
inline bool Location::_internal_has_degreeslongitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Location::has_degreeslongitude() const {
  return _internal_has_degreeslongitude();
}
inline void Location::clear_degreeslongitude() {
  _impl_.degreeslongitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double Location::_internal_degreeslongitude() const {
  return _impl_.degreeslongitude_;
}
inline double Location::degreeslongitude() const {
  // @@protoc_insertion_point(field_get:proto.Location.degreesLongitude)
  return _internal_degreeslongitude();
}
inline void Location::_internal_set_degreeslongitude(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.degreeslongitude_ = value;
}
inline void Location::set_degreeslongitude(double value) {
  _internal_set_degreeslongitude(value);
  // @@protoc_insertion_point(field_set:proto.Location.degreesLongitude)
}

// optional string name = 3;
inline bool Location::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Location::has_name() const {
  return _internal_has_name();
}
inline void Location::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Location::name() const {
  // @@protoc_insertion_point(field_get:proto.Location.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Location::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Location.name)
}
inline std::string* Location::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Location.name)
  return _s;
}
inline const std::string& Location::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Location::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Location::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Location::release_name() {
  // @@protoc_insertion_point(field_release:proto.Location.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Location::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Location.name)
}

// -------------------------------------------------------------------

// MediaData

// optional string localPath = 1;
inline bool MediaData::_internal_has_localpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MediaData::has_localpath() const {
  return _internal_has_localpath();
}
inline void MediaData::clear_localpath() {
  _impl_.localpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MediaData::localpath() const {
  // @@protoc_insertion_point(field_get:proto.MediaData.localPath)
  return _internal_localpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MediaData::set_localpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.localpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MediaData.localPath)
}
inline std::string* MediaData::mutable_localpath() {
  std::string* _s = _internal_mutable_localpath();
  // @@protoc_insertion_point(field_mutable:proto.MediaData.localPath)
  return _s;
}
inline const std::string& MediaData::_internal_localpath() const {
  return _impl_.localpath_.Get();
}
inline void MediaData::_internal_set_localpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.localpath_.Set(value, GetArenaForAllocation());
}
inline std::string* MediaData::_internal_mutable_localpath() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.localpath_.Mutable(GetArenaForAllocation());
}
inline std::string* MediaData::release_localpath() {
  // @@protoc_insertion_point(field_release:proto.MediaData.localPath)
  if (!_internal_has_localpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.localpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localpath_.IsDefault()) {
    _impl_.localpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MediaData::set_allocated_localpath(std::string* localpath) {
  if (localpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.localpath_.SetAllocated(localpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localpath_.IsDefault()) {
    _impl_.localpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MediaData.localPath)
}

// -------------------------------------------------------------------

// MediaRetryNotification

// optional string stanzaId = 1;
inline bool MediaRetryNotification::_internal_has_stanzaid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MediaRetryNotification::has_stanzaid() const {
  return _internal_has_stanzaid();
}
inline void MediaRetryNotification::clear_stanzaid() {
  _impl_.stanzaid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MediaRetryNotification::stanzaid() const {
  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.stanzaId)
  return _internal_stanzaid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MediaRetryNotification::set_stanzaid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.stanzaId)
}
inline std::string* MediaRetryNotification::mutable_stanzaid() {
  std::string* _s = _internal_mutable_stanzaid();
  // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.stanzaId)
  return _s;
}
inline const std::string& MediaRetryNotification::_internal_stanzaid() const {
  return _impl_.stanzaid_.Get();
}
inline void MediaRetryNotification::_internal_set_stanzaid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
}
inline std::string* MediaRetryNotification::_internal_mutable_stanzaid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
}
inline std::string* MediaRetryNotification::release_stanzaid() {
  // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.stanzaId)
  if (!_internal_has_stanzaid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.stanzaid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MediaRetryNotification::set_allocated_stanzaid(std::string* stanzaid) {
  if (stanzaid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.stanzaId)
}

// optional string directPath = 2;
inline bool MediaRetryNotification::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MediaRetryNotification::has_directpath() const {
  return _internal_has_directpath();
}
inline void MediaRetryNotification::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MediaRetryNotification::directpath() const {
  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MediaRetryNotification::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.directPath)
}
inline std::string* MediaRetryNotification::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.MediaRetryNotification.directPath)
  return _s;
}
inline const std::string& MediaRetryNotification::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void MediaRetryNotification::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* MediaRetryNotification::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* MediaRetryNotification::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.MediaRetryNotification.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MediaRetryNotification::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MediaRetryNotification.directPath)
}

// optional .proto.MediaRetryNotification.ResultType result = 3;
inline bool MediaRetryNotification::_internal_has_result() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MediaRetryNotification::has_result() const {
  return _internal_has_result();
}
inline void MediaRetryNotification::clear_result() {
  _impl_.result_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::_internal_result() const {
  return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.result_);
}
inline ::proto::MediaRetryNotification_ResultType MediaRetryNotification::result() const {
  // @@protoc_insertion_point(field_get:proto.MediaRetryNotification.result)
  return _internal_result();
}
inline void MediaRetryNotification::_internal_set_result(::proto::MediaRetryNotification_ResultType value) {
  assert(::proto::MediaRetryNotification_ResultType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.result_ = value;
}
inline void MediaRetryNotification::set_result(::proto::MediaRetryNotification_ResultType value) {
  _internal_set_result(value);
  // @@protoc_insertion_point(field_set:proto.MediaRetryNotification.result)
}

// -------------------------------------------------------------------

// Message_AppStateFatalExceptionNotification

// repeated string collectionNames = 1;
inline int Message_AppStateFatalExceptionNotification::_internal_collectionnames_size() const {
  return _impl_.collectionnames_.size();
}
inline int Message_AppStateFatalExceptionNotification::collectionnames_size() const {
  return _internal_collectionnames_size();
}
inline void Message_AppStateFatalExceptionNotification::clear_collectionnames() {
  _impl_.collectionnames_.Clear();
}
inline std::string* Message_AppStateFatalExceptionNotification::add_collectionnames() {
  std::string* _s = _internal_add_collectionnames();
  // @@protoc_insertion_point(field_add_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames)
  return _s;
}
inline const std::string& Message_AppStateFatalExceptionNotification::_internal_collectionnames(int index) const {
  return _impl_.collectionnames_.Get(index);
}
inline const std::string& Message_AppStateFatalExceptionNotification::collectionnames(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.collectionNames)
  return _internal_collectionnames(index);
}
inline std::string* Message_AppStateFatalExceptionNotification::mutable_collectionnames(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateFatalExceptionNotification.collectionNames)
  return _impl_.collectionnames_.Mutable(index);
}
inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const std::string& value) {
  _impl_.collectionnames_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, std::string&& value) {
  _impl_.collectionnames_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.collectionnames_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::set_collectionnames(int index, const char* value, size_t size) {
  _impl_.collectionnames_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline std::string* Message_AppStateFatalExceptionNotification::_internal_add_collectionnames() {
  return _impl_.collectionnames_.Add();
}
inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const std::string& value) {
  _impl_.collectionnames_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::add_collectionnames(std::string&& value) {
  _impl_.collectionnames_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.collectionnames_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline void Message_AppStateFatalExceptionNotification::add_collectionnames(const char* value, size_t size) {
  _impl_.collectionnames_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.Message.AppStateFatalExceptionNotification.collectionNames)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Message_AppStateFatalExceptionNotification::collectionnames() const {
  // @@protoc_insertion_point(field_list:proto.Message.AppStateFatalExceptionNotification.collectionNames)
  return _impl_.collectionnames_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Message_AppStateFatalExceptionNotification::mutable_collectionnames() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateFatalExceptionNotification.collectionNames)
  return &_impl_.collectionnames_;
}

// optional int64 timestamp = 2;
inline bool Message_AppStateFatalExceptionNotification::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_AppStateFatalExceptionNotification::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void Message_AppStateFatalExceptionNotification::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t Message_AppStateFatalExceptionNotification::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Message_AppStateFatalExceptionNotification::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateFatalExceptionNotification.timestamp)
  return _internal_timestamp();
}
inline void Message_AppStateFatalExceptionNotification::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void Message_AppStateFatalExceptionNotification::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateFatalExceptionNotification.timestamp)
}

// -------------------------------------------------------------------

// Message_AppStateSyncKeyData

// optional bytes keyData = 1;
inline bool Message_AppStateSyncKeyData::_internal_has_keydata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_AppStateSyncKeyData::has_keydata() const {
  return _internal_has_keydata();
}
inline void Message_AppStateSyncKeyData::clear_keydata() {
  _impl_.keydata_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_AppStateSyncKeyData::keydata() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.keyData)
  return _internal_keydata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AppStateSyncKeyData::set_keydata(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.keydata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.keyData)
}
inline std::string* Message_AppStateSyncKeyData::mutable_keydata() {
  std::string* _s = _internal_mutable_keydata();
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.keyData)
  return _s;
}
inline const std::string& Message_AppStateSyncKeyData::_internal_keydata() const {
  return _impl_.keydata_.Get();
}
inline void Message_AppStateSyncKeyData::_internal_set_keydata(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.keydata_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AppStateSyncKeyData::_internal_mutable_keydata() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.keydata_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AppStateSyncKeyData::release_keydata() {
  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.keyData)
  if (!_internal_has_keydata()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.keydata_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.keydata_.IsDefault()) {
    _impl_.keydata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AppStateSyncKeyData::set_allocated_keydata(std::string* keydata) {
  if (keydata != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.keydata_.SetAllocated(keydata, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.keydata_.IsDefault()) {
    _impl_.keydata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.keyData)
}

// optional .proto.Message.AppStateSyncKeyFingerprint fingerprint = 2;
inline bool Message_AppStateSyncKeyData::_internal_has_fingerprint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fingerprint_ != nullptr);
  return value;
}
inline bool Message_AppStateSyncKeyData::has_fingerprint() const {
  return _internal_has_fingerprint();
}
inline void Message_AppStateSyncKeyData::clear_fingerprint() {
  if (_impl_.fingerprint_ != nullptr) _impl_.fingerprint_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::_internal_fingerprint() const {
  const ::proto::Message_AppStateSyncKeyFingerprint* p = _impl_.fingerprint_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyFingerprint&>(
      ::proto::_Message_AppStateSyncKeyFingerprint_default_instance_);
}
inline const ::proto::Message_AppStateSyncKeyFingerprint& Message_AppStateSyncKeyData::fingerprint() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.fingerprint)
  return _internal_fingerprint();
}
inline void Message_AppStateSyncKeyData::unsafe_arena_set_allocated_fingerprint(
    ::proto::Message_AppStateSyncKeyFingerprint* fingerprint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fingerprint_);
  }
  _impl_.fingerprint_ = fingerprint;
  if (fingerprint) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint)
}
inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::release_fingerprint() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_;
  _impl_.fingerprint_ = 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 ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::unsafe_arena_release_fingerprint() {
  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyData.fingerprint)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_AppStateSyncKeyFingerprint* temp = _impl_.fingerprint_;
  _impl_.fingerprint_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::_internal_mutable_fingerprint() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.fingerprint_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyFingerprint>(GetArenaForAllocation());
    _impl_.fingerprint_ = p;
  }
  return _impl_.fingerprint_;
}
inline ::proto::Message_AppStateSyncKeyFingerprint* Message_AppStateSyncKeyData::mutable_fingerprint() {
  ::proto::Message_AppStateSyncKeyFingerprint* _msg = _internal_mutable_fingerprint();
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyData.fingerprint)
  return _msg;
}
inline void Message_AppStateSyncKeyData::set_allocated_fingerprint(::proto::Message_AppStateSyncKeyFingerprint* fingerprint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.fingerprint_;
  }
  if (fingerprint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fingerprint);
    if (message_arena != submessage_arena) {
      fingerprint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fingerprint, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.fingerprint_ = fingerprint;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyData.fingerprint)
}

// optional int64 timestamp = 3;
inline bool Message_AppStateSyncKeyData::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_AppStateSyncKeyData::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void Message_AppStateSyncKeyData::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t Message_AppStateSyncKeyData::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Message_AppStateSyncKeyData::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyData.timestamp)
  return _internal_timestamp();
}
inline void Message_AppStateSyncKeyData::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.timestamp_ = value;
}
inline void Message_AppStateSyncKeyData::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyData.timestamp)
}

// -------------------------------------------------------------------

// Message_AppStateSyncKeyFingerprint

// optional uint32 rawId = 1;
inline bool Message_AppStateSyncKeyFingerprint::_internal_has_rawid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_AppStateSyncKeyFingerprint::has_rawid() const {
  return _internal_has_rawid();
}
inline void Message_AppStateSyncKeyFingerprint::clear_rawid() {
  _impl_.rawid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_rawid() const {
  return _impl_.rawid_;
}
inline uint32_t Message_AppStateSyncKeyFingerprint::rawid() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.rawId)
  return _internal_rawid();
}
inline void Message_AppStateSyncKeyFingerprint::_internal_set_rawid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rawid_ = value;
}
inline void Message_AppStateSyncKeyFingerprint::set_rawid(uint32_t value) {
  _internal_set_rawid(value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.rawId)
}

// optional uint32 currentIndex = 2;
inline bool Message_AppStateSyncKeyFingerprint::_internal_has_currentindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_AppStateSyncKeyFingerprint::has_currentindex() const {
  return _internal_has_currentindex();
}
inline void Message_AppStateSyncKeyFingerprint::clear_currentindex() {
  _impl_.currentindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_currentindex() const {
  return _impl_.currentindex_;
}
inline uint32_t Message_AppStateSyncKeyFingerprint::currentindex() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.currentIndex)
  return _internal_currentindex();
}
inline void Message_AppStateSyncKeyFingerprint::_internal_set_currentindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.currentindex_ = value;
}
inline void Message_AppStateSyncKeyFingerprint::set_currentindex(uint32_t value) {
  _internal_set_currentindex(value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.currentIndex)
}

// repeated uint32 deviceIndexes = 3 [packed = true];
inline int Message_AppStateSyncKeyFingerprint::_internal_deviceindexes_size() const {
  return _impl_.deviceindexes_.size();
}
inline int Message_AppStateSyncKeyFingerprint::deviceindexes_size() const {
  return _internal_deviceindexes_size();
}
inline void Message_AppStateSyncKeyFingerprint::clear_deviceindexes() {
  _impl_.deviceindexes_.Clear();
}
inline uint32_t Message_AppStateSyncKeyFingerprint::_internal_deviceindexes(int index) const {
  return _impl_.deviceindexes_.Get(index);
}
inline uint32_t Message_AppStateSyncKeyFingerprint::deviceindexes(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
  return _internal_deviceindexes(index);
}
inline void Message_AppStateSyncKeyFingerprint::set_deviceindexes(int index, uint32_t value) {
  _impl_.deviceindexes_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
}
inline void Message_AppStateSyncKeyFingerprint::_internal_add_deviceindexes(uint32_t value) {
  _impl_.deviceindexes_.Add(value);
}
inline void Message_AppStateSyncKeyFingerprint::add_deviceindexes(uint32_t value) {
  _internal_add_deviceindexes(value);
  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Message_AppStateSyncKeyFingerprint::_internal_deviceindexes() const {
  return _impl_.deviceindexes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Message_AppStateSyncKeyFingerprint::deviceindexes() const {
  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
  return _internal_deviceindexes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Message_AppStateSyncKeyFingerprint::_internal_mutable_deviceindexes() {
  return &_impl_.deviceindexes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Message_AppStateSyncKeyFingerprint::mutable_deviceindexes() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyFingerprint.deviceIndexes)
  return _internal_mutable_deviceindexes();
}

// -------------------------------------------------------------------

// Message_AppStateSyncKeyId

// optional bytes keyId = 1;
inline bool Message_AppStateSyncKeyId::_internal_has_keyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_AppStateSyncKeyId::has_keyid() const {
  return _internal_has_keyid();
}
inline void Message_AppStateSyncKeyId::clear_keyid() {
  _impl_.keyid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_AppStateSyncKeyId::keyid() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyId.keyId)
  return _internal_keyid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AppStateSyncKeyId::set_keyid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.keyid_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AppStateSyncKeyId.keyId)
}
inline std::string* Message_AppStateSyncKeyId::mutable_keyid() {
  std::string* _s = _internal_mutable_keyid();
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyId.keyId)
  return _s;
}
inline const std::string& Message_AppStateSyncKeyId::_internal_keyid() const {
  return _impl_.keyid_.Get();
}
inline void Message_AppStateSyncKeyId::_internal_set_keyid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.keyid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AppStateSyncKeyId::_internal_mutable_keyid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.keyid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AppStateSyncKeyId::release_keyid() {
  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKeyId.keyId)
  if (!_internal_has_keyid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.keyid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.keyid_.IsDefault()) {
    _impl_.keyid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AppStateSyncKeyId::set_allocated_keyid(std::string* keyid) {
  if (keyid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.keyid_.SetAllocated(keyid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.keyid_.IsDefault()) {
    _impl_.keyid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKeyId.keyId)
}

// -------------------------------------------------------------------

// Message_AppStateSyncKeyRequest

// repeated .proto.Message.AppStateSyncKeyId keyIds = 1;
inline int Message_AppStateSyncKeyRequest::_internal_keyids_size() const {
  return _impl_.keyids_.size();
}
inline int Message_AppStateSyncKeyRequest::keyids_size() const {
  return _internal_keyids_size();
}
inline void Message_AppStateSyncKeyRequest::clear_keyids() {
  _impl_.keyids_.Clear();
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::mutable_keyids(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyRequest.keyIds)
  return _impl_.keyids_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >*
Message_AppStateSyncKeyRequest::mutable_keyids() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyRequest.keyIds)
  return &_impl_.keyids_;
}
inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::_internal_keyids(int index) const {
  return _impl_.keyids_.Get(index);
}
inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKeyRequest::keyids(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyRequest.keyIds)
  return _internal_keyids(index);
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::_internal_add_keyids() {
  return _impl_.keyids_.Add();
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKeyRequest::add_keyids() {
  ::proto::Message_AppStateSyncKeyId* _add = _internal_add_keyids();
  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyRequest.keyIds)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKeyId >&
Message_AppStateSyncKeyRequest::keyids() const {
  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyRequest.keyIds)
  return _impl_.keyids_;
}

// -------------------------------------------------------------------

// Message_AppStateSyncKeyShare

// repeated .proto.Message.AppStateSyncKey keys = 1;
inline int Message_AppStateSyncKeyShare::_internal_keys_size() const {
  return _impl_.keys_.size();
}
inline int Message_AppStateSyncKeyShare::keys_size() const {
  return _internal_keys_size();
}
inline void Message_AppStateSyncKeyShare::clear_keys() {
  _impl_.keys_.Clear();
}
inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::mutable_keys(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKeyShare.keys)
  return _impl_.keys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >*
Message_AppStateSyncKeyShare::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.AppStateSyncKeyShare.keys)
  return &_impl_.keys_;
}
inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::_internal_keys(int index) const {
  return _impl_.keys_.Get(index);
}
inline const ::proto::Message_AppStateSyncKey& Message_AppStateSyncKeyShare::keys(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKeyShare.keys)
  return _internal_keys(index);
}
inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::_internal_add_keys() {
  return _impl_.keys_.Add();
}
inline ::proto::Message_AppStateSyncKey* Message_AppStateSyncKeyShare::add_keys() {
  ::proto::Message_AppStateSyncKey* _add = _internal_add_keys();
  // @@protoc_insertion_point(field_add:proto.Message.AppStateSyncKeyShare.keys)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_AppStateSyncKey >&
Message_AppStateSyncKeyShare::keys() const {
  // @@protoc_insertion_point(field_list:proto.Message.AppStateSyncKeyShare.keys)
  return _impl_.keys_;
}

// -------------------------------------------------------------------

// Message_AppStateSyncKey

// optional .proto.Message.AppStateSyncKeyId keyId = 1;
inline bool Message_AppStateSyncKey::_internal_has_keyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
  return value;
}
inline bool Message_AppStateSyncKey::has_keyid() const {
  return _internal_has_keyid();
}
inline void Message_AppStateSyncKey::clear_keyid() {
  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::_internal_keyid() const {
  const ::proto::Message_AppStateSyncKeyId* p = _impl_.keyid_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyId&>(
      ::proto::_Message_AppStateSyncKeyId_default_instance_);
}
inline const ::proto::Message_AppStateSyncKeyId& Message_AppStateSyncKey::keyid() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyId)
  return _internal_keyid();
}
inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keyid(
    ::proto::Message_AppStateSyncKeyId* keyid) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
  }
  _impl_.keyid_ = keyid;
  if (keyid) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyId)
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::release_keyid() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = 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 ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::unsafe_arena_release_keyid() {
  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyId)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_AppStateSyncKeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::_internal_mutable_keyid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.keyid_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyId>(GetArenaForAllocation());
    _impl_.keyid_ = p;
  }
  return _impl_.keyid_;
}
inline ::proto::Message_AppStateSyncKeyId* Message_AppStateSyncKey::mutable_keyid() {
  ::proto::Message_AppStateSyncKeyId* _msg = _internal_mutable_keyid();
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyId)
  return _msg;
}
inline void Message_AppStateSyncKey::set_allocated_keyid(::proto::Message_AppStateSyncKeyId* keyid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keyid_;
  }
  if (keyid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
    if (message_arena != submessage_arena) {
      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keyid, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.keyid_ = keyid;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyId)
}

// optional .proto.Message.AppStateSyncKeyData keyData = 2;
inline bool Message_AppStateSyncKey::_internal_has_keydata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keydata_ != nullptr);
  return value;
}
inline bool Message_AppStateSyncKey::has_keydata() const {
  return _internal_has_keydata();
}
inline void Message_AppStateSyncKey::clear_keydata() {
  if (_impl_.keydata_ != nullptr) _impl_.keydata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::_internal_keydata() const {
  const ::proto::Message_AppStateSyncKeyData* p = _impl_.keydata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyData&>(
      ::proto::_Message_AppStateSyncKeyData_default_instance_);
}
inline const ::proto::Message_AppStateSyncKeyData& Message_AppStateSyncKey::keydata() const {
  // @@protoc_insertion_point(field_get:proto.Message.AppStateSyncKey.keyData)
  return _internal_keydata();
}
inline void Message_AppStateSyncKey::unsafe_arena_set_allocated_keydata(
    ::proto::Message_AppStateSyncKeyData* keydata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keydata_);
  }
  _impl_.keydata_ = keydata;
  if (keydata) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AppStateSyncKey.keyData)
}
inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::release_keydata() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_;
  _impl_.keydata_ = 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 ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::unsafe_arena_release_keydata() {
  // @@protoc_insertion_point(field_release:proto.Message.AppStateSyncKey.keyData)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_AppStateSyncKeyData* temp = _impl_.keydata_;
  _impl_.keydata_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::_internal_mutable_keydata() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.keydata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyData>(GetArenaForAllocation());
    _impl_.keydata_ = p;
  }
  return _impl_.keydata_;
}
inline ::proto::Message_AppStateSyncKeyData* Message_AppStateSyncKey::mutable_keydata() {
  ::proto::Message_AppStateSyncKeyData* _msg = _internal_mutable_keydata();
  // @@protoc_insertion_point(field_mutable:proto.Message.AppStateSyncKey.keyData)
  return _msg;
}
inline void Message_AppStateSyncKey::set_allocated_keydata(::proto::Message_AppStateSyncKeyData* keydata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keydata_;
  }
  if (keydata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keydata);
    if (message_arena != submessage_arena) {
      keydata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keydata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.keydata_ = keydata;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AppStateSyncKey.keyData)
}

// -------------------------------------------------------------------

// Message_AudioMessage

// optional string url = 1;
inline bool Message_AudioMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_AudioMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_AudioMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::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:proto.Message.AudioMessage.url)
}
inline std::string* Message_AudioMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.url)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_AudioMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.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 Message_AudioMessage::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:proto.Message.AudioMessage.url)
}

// optional string mimetype = 2;
inline bool Message_AudioMessage::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void Message_AudioMessage::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_AudioMessage::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mimetype)
}
inline std::string* Message_AudioMessage::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mimetype)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void Message_AudioMessage::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mimetype)
}

// optional bytes fileSha256 = 3;
inline bool Message_AudioMessage::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_AudioMessage::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_AudioMessage::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileSha256)
}
inline std::string* Message_AudioMessage::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileSha256)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_AudioMessage::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileSha256)
}

// optional uint64 fileLength = 4;
inline bool Message_AudioMessage::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_AudioMessage::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t Message_AudioMessage::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_AudioMessage::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileLength)
  return _internal_filelength();
}
inline void Message_AudioMessage::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.filelength_ = value;
}
inline void Message_AudioMessage::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileLength)
}

// optional uint32 seconds = 5;
inline bool Message_AudioMessage::_internal_has_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_seconds() const {
  return _internal_has_seconds();
}
inline void Message_AudioMessage::clear_seconds() {
  _impl_.seconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Message_AudioMessage::_internal_seconds() const {
  return _impl_.seconds_;
}
inline uint32_t Message_AudioMessage::seconds() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.seconds)
  return _internal_seconds();
}
inline void Message_AudioMessage::_internal_set_seconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.seconds_ = value;
}
inline void Message_AudioMessage::set_seconds(uint32_t value) {
  _internal_set_seconds(value);
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.seconds)
}

// optional bool ptt = 6;
inline bool Message_AudioMessage::_internal_has_ptt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_ptt() const {
  return _internal_has_ptt();
}
inline void Message_AudioMessage::clear_ptt() {
  _impl_.ptt_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool Message_AudioMessage::_internal_ptt() const {
  return _impl_.ptt_;
}
inline bool Message_AudioMessage::ptt() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.ptt)
  return _internal_ptt();
}
inline void Message_AudioMessage::_internal_set_ptt(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.ptt_ = value;
}
inline void Message_AudioMessage::set_ptt(bool value) {
  _internal_set_ptt(value);
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.ptt)
}

// optional bytes mediaKey = 7;
inline bool Message_AudioMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_AudioMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_AudioMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKey)
}
inline std::string* Message_AudioMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.mediaKey)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_AudioMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.mediaKey)
}

// optional bytes fileEncSha256 = 8;
inline bool Message_AudioMessage::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_AudioMessage::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_AudioMessage::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.fileEncSha256)
}
inline std::string* Message_AudioMessage::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.fileEncSha256)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_AudioMessage::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.fileEncSha256)
}

// optional string directPath = 9;
inline bool Message_AudioMessage::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_AudioMessage::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_AudioMessage::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.directPath)
}
inline std::string* Message_AudioMessage::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.directPath)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_AudioMessage::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.directPath)
}

// optional int64 mediaKeyTimestamp = 10;
inline bool Message_AudioMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_AudioMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int64_t Message_AudioMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_AudioMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_AudioMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_AudioMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.mediaKeyTimestamp)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_AudioMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_AudioMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_AudioMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::ContextInfo& Message_AudioMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_AudioMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_AudioMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.AudioMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_AudioMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_AudioMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_AudioMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_AudioMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.contextInfo)
  return _msg;
}
inline void Message_AudioMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.contextInfo)
}

// optional bytes streamingSidecar = 18;
inline bool Message_AudioMessage::_internal_has_streamingsidecar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_streamingsidecar() const {
  return _internal_has_streamingsidecar();
}
inline void Message_AudioMessage::clear_streamingsidecar() {
  _impl_.streamingsidecar_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_AudioMessage::streamingsidecar() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.streamingSidecar)
  return _internal_streamingsidecar();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.streamingsidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.streamingSidecar)
}
inline std::string* Message_AudioMessage::mutable_streamingsidecar() {
  std::string* _s = _internal_mutable_streamingsidecar();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.streamingSidecar)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_streamingsidecar() const {
  return _impl_.streamingsidecar_.Get();
}
inline void Message_AudioMessage::_internal_set_streamingsidecar(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.streamingsidecar_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_streamingsidecar() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_streamingsidecar() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.streamingSidecar)
  if (!_internal_has_streamingsidecar()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.streamingsidecar_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.streamingsidecar_.IsDefault()) {
    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) {
  if (streamingsidecar != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.streamingsidecar_.IsDefault()) {
    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.streamingSidecar)
}

// optional bytes waveform = 19;
inline bool Message_AudioMessage::_internal_has_waveform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_AudioMessage::has_waveform() const {
  return _internal_has_waveform();
}
inline void Message_AudioMessage::clear_waveform() {
  _impl_.waveform_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_AudioMessage::waveform() const {
  // @@protoc_insertion_point(field_get:proto.Message.AudioMessage.waveform)
  return _internal_waveform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_AudioMessage::set_waveform(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.waveform_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.AudioMessage.waveform)
}
inline std::string* Message_AudioMessage::mutable_waveform() {
  std::string* _s = _internal_mutable_waveform();
  // @@protoc_insertion_point(field_mutable:proto.Message.AudioMessage.waveform)
  return _s;
}
inline const std::string& Message_AudioMessage::_internal_waveform() const {
  return _impl_.waveform_.Get();
}
inline void Message_AudioMessage::_internal_set_waveform(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.waveform_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::_internal_mutable_waveform() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.waveform_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_AudioMessage::release_waveform() {
  // @@protoc_insertion_point(field_release:proto.Message.AudioMessage.waveform)
  if (!_internal_has_waveform()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.waveform_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.waveform_.IsDefault()) {
    _impl_.waveform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_AudioMessage::set_allocated_waveform(std::string* waveform) {
  if (waveform != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.waveform_.SetAllocated(waveform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.waveform_.IsDefault()) {
    _impl_.waveform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.AudioMessage.waveform)
}

// -------------------------------------------------------------------

// Message_ButtonsMessage_Button_ButtonText

// optional string displayText = 1;
inline bool Message_ButtonsMessage_Button_ButtonText::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ButtonsMessage_Button_ButtonText::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void Message_ButtonsMessage_Button_ButtonText::clear_displaytext() {
  _impl_.displaytext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ButtonsMessage_Button_ButtonText::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
  return _internal_displaytext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage_Button_ButtonText::set_displaytext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.displaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
}
inline std::string* Message_ButtonsMessage_Button_ButtonText::mutable_displaytext() {
  std::string* _s = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
  return _s;
}
inline const std::string& Message_ButtonsMessage_Button_ButtonText::_internal_displaytext() const {
  return _impl_.displaytext_.Get();
}
inline void Message_ButtonsMessage_Button_ButtonText::_internal_set_displaytext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_ButtonText::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displaytext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_ButtonText::release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
  if (!_internal_has_displaytext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.displaytext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsMessage_Button_ButtonText::set_allocated_displaytext(std::string* displaytext) {
  if (displaytext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_.SetAllocated(displaytext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.displaytext_.IsDefault()) {
    _impl_.displaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.ButtonText.displayText)
}

// -------------------------------------------------------------------

// Message_ButtonsMessage_Button_NativeFlowInfo

// optional string name = 1;
inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_name() const {
  return _internal_has_name();
}
inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::name() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage_Button_NativeFlowInfo::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
  return _s;
}
inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_name() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ButtonsMessage.Button.NativeFlowInfo.name)
}

// optional string paramsJson = 2;
inline bool Message_ButtonsMessage_Button_NativeFlowInfo::_internal_has_paramsjson() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ButtonsMessage_Button_NativeFlowInfo::has_paramsjson() const {
  return _internal_has_paramsjson();
}
inline void Message_ButtonsMessage_Button_NativeFlowInfo::clear_paramsjson() {
  _impl_.paramsjson_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::paramsjson() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
  return _internal_paramsjson();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage_Button_NativeFlowInfo::set_paramsjson(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.paramsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::mutable_paramsjson() {
  std::string* _s = _internal_mutable_paramsjson();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
  return _s;
}
inline const std::string& Message_ButtonsMessage_Button_NativeFlowInfo::_internal_paramsjson() const {
  return _impl_.paramsjson_.Get();
}
inline void Message_ButtonsMessage_Button_NativeFlowInfo::_internal_set_paramsjson(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.paramsjson_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::_internal_mutable_paramsjson() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.paramsjson_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button_NativeFlowInfo::release_paramsjson() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
  if (!_internal_has_paramsjson()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.paramsjson_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paramsjson_.IsDefault()) {
    _impl_.paramsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsMessage_Button_NativeFlowInfo::set_allocated_paramsjson(std::string* paramsjson) {
  if (paramsjson != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paramsjson_.IsDefault()) {
    _impl_.paramsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.NativeFlowInfo.paramsJson)
}

// -------------------------------------------------------------------

// Message_ButtonsMessage_Button

// optional string buttonId = 1;
inline bool Message_ButtonsMessage_Button::_internal_has_buttonid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ButtonsMessage_Button::has_buttonid() const {
  return _internal_has_buttonid();
}
inline void Message_ButtonsMessage_Button::clear_buttonid() {
  _impl_.buttonid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ButtonsMessage_Button::buttonid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonId)
  return _internal_buttonid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage_Button::set_buttonid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.buttonid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.buttonId)
}
inline std::string* Message_ButtonsMessage_Button::mutable_buttonid() {
  std::string* _s = _internal_mutable_buttonid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonId)
  return _s;
}
inline const std::string& Message_ButtonsMessage_Button::_internal_buttonid() const {
  return _impl_.buttonid_.Get();
}
inline void Message_ButtonsMessage_Button::_internal_set_buttonid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.buttonid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button::_internal_mutable_buttonid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.buttonid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage_Button::release_buttonid() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonId)
  if (!_internal_has_buttonid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.buttonid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttonid_.IsDefault()) {
    _impl_.buttonid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsMessage_Button::set_allocated_buttonid(std::string* buttonid) {
  if (buttonid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.buttonid_.SetAllocated(buttonid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttonid_.IsDefault()) {
    _impl_.buttonid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonId)
}

// optional .proto.Message.ButtonsMessage.Button.ButtonText buttonText = 2;
inline bool Message_ButtonsMessage_Button::_internal_has_buttontext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.buttontext_ != nullptr);
  return value;
}
inline bool Message_ButtonsMessage_Button::has_buttontext() const {
  return _internal_has_buttontext();
}
inline void Message_ButtonsMessage_Button::clear_buttontext() {
  if (_impl_.buttontext_ != nullptr) _impl_.buttontext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::_internal_buttontext() const {
  const ::proto::Message_ButtonsMessage_Button_ButtonText* p = _impl_.buttontext_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage_Button_ButtonText&>(
      ::proto::_Message_ButtonsMessage_Button_ButtonText_default_instance_);
}
inline const ::proto::Message_ButtonsMessage_Button_ButtonText& Message_ButtonsMessage_Button::buttontext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.buttonText)
  return _internal_buttontext();
}
inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_buttontext(
    ::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttontext_);
  }
  _impl_.buttontext_ = buttontext;
  if (buttontext) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.buttonText)
}
inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::release_buttontext() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_;
  _impl_.buttontext_ = 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 ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::unsafe_arena_release_buttontext() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.buttonText)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_ButtonsMessage_Button_ButtonText* temp = _impl_.buttontext_;
  _impl_.buttontext_ = nullptr;
  return temp;
}
inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::_internal_mutable_buttontext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.buttontext_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_ButtonText>(GetArenaForAllocation());
    _impl_.buttontext_ = p;
  }
  return _impl_.buttontext_;
}
inline ::proto::Message_ButtonsMessage_Button_ButtonText* Message_ButtonsMessage_Button::mutable_buttontext() {
  ::proto::Message_ButtonsMessage_Button_ButtonText* _msg = _internal_mutable_buttontext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.buttonText)
  return _msg;
}
inline void Message_ButtonsMessage_Button::set_allocated_buttontext(::proto::Message_ButtonsMessage_Button_ButtonText* buttontext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.buttontext_;
  }
  if (buttontext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttontext);
    if (message_arena != submessage_arena) {
      buttontext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buttontext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.buttontext_ = buttontext;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.buttonText)
}

// optional .proto.Message.ButtonsMessage.Button.Type type = 3;
inline bool Message_ButtonsMessage_Button::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ButtonsMessage_Button::has_type() const {
  return _internal_has_type();
}
inline void Message_ButtonsMessage_Button::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::_internal_type() const {
  return static_cast< ::proto::Message_ButtonsMessage_Button_Type >(_impl_.type_);
}
inline ::proto::Message_ButtonsMessage_Button_Type Message_ButtonsMessage_Button::type() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.type)
  return _internal_type();
}
inline void Message_ButtonsMessage_Button::_internal_set_type(::proto::Message_ButtonsMessage_Button_Type value) {
  assert(::proto::Message_ButtonsMessage_Button_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.type_ = value;
}
inline void Message_ButtonsMessage_Button::set_type(::proto::Message_ButtonsMessage_Button_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.Button.type)
}

// optional .proto.Message.ButtonsMessage.Button.NativeFlowInfo nativeFlowInfo = 4;
inline bool Message_ButtonsMessage_Button::_internal_has_nativeflowinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.nativeflowinfo_ != nullptr);
  return value;
}
inline bool Message_ButtonsMessage_Button::has_nativeflowinfo() const {
  return _internal_has_nativeflowinfo();
}
inline void Message_ButtonsMessage_Button::clear_nativeflowinfo() {
  if (_impl_.nativeflowinfo_ != nullptr) _impl_.nativeflowinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::_internal_nativeflowinfo() const {
  const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* p = _impl_.nativeflowinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo&>(
      ::proto::_Message_ButtonsMessage_Button_NativeFlowInfo_default_instance_);
}
inline const ::proto::Message_ButtonsMessage_Button_NativeFlowInfo& Message_ButtonsMessage_Button::nativeflowinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
  return _internal_nativeflowinfo();
}
inline void Message_ButtonsMessage_Button::unsafe_arena_set_allocated_nativeflowinfo(
    ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nativeflowinfo_);
  }
  _impl_.nativeflowinfo_ = nativeflowinfo;
  if (nativeflowinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
}
inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::release_nativeflowinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_;
  _impl_.nativeflowinfo_ = 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 ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::unsafe_arena_release_nativeflowinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* temp = _impl_.nativeflowinfo_;
  _impl_.nativeflowinfo_ = nullptr;
  return temp;
}
inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::_internal_mutable_nativeflowinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.nativeflowinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage_Button_NativeFlowInfo>(GetArenaForAllocation());
    _impl_.nativeflowinfo_ = p;
  }
  return _impl_.nativeflowinfo_;
}
inline ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* Message_ButtonsMessage_Button::mutable_nativeflowinfo() {
  ::proto::Message_ButtonsMessage_Button_NativeFlowInfo* _msg = _internal_mutable_nativeflowinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
  return _msg;
}
inline void Message_ButtonsMessage_Button::set_allocated_nativeflowinfo(::proto::Message_ButtonsMessage_Button_NativeFlowInfo* nativeflowinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.nativeflowinfo_;
  }
  if (nativeflowinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nativeflowinfo);
    if (message_arena != submessage_arena) {
      nativeflowinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nativeflowinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.nativeflowinfo_ = nativeflowinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.Button.nativeFlowInfo)
}

// -------------------------------------------------------------------

// Message_ButtonsMessage

// optional string contentText = 6;
inline bool Message_ButtonsMessage::_internal_has_contenttext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ButtonsMessage::has_contenttext() const {
  return _internal_has_contenttext();
}
inline void Message_ButtonsMessage::clear_contenttext() {
  _impl_.contenttext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ButtonsMessage::contenttext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contentText)
  return _internal_contenttext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage::set_contenttext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.contenttext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.contentText)
}
inline std::string* Message_ButtonsMessage::mutable_contenttext() {
  std::string* _s = _internal_mutable_contenttext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contentText)
  return _s;
}
inline const std::string& Message_ButtonsMessage::_internal_contenttext() const {
  return _impl_.contenttext_.Get();
}
inline void Message_ButtonsMessage::_internal_set_contenttext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.contenttext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::_internal_mutable_contenttext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.contenttext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::release_contenttext() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contentText)
  if (!_internal_has_contenttext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.contenttext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttext_.IsDefault()) {
    _impl_.contenttext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsMessage::set_allocated_contenttext(std::string* contenttext) {
  if (contenttext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contenttext_.SetAllocated(contenttext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.contenttext_.IsDefault()) {
    _impl_.contenttext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contentText)
}

// optional string footerText = 7;
inline bool Message_ButtonsMessage::_internal_has_footertext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ButtonsMessage::has_footertext() const {
  return _internal_has_footertext();
}
inline void Message_ButtonsMessage::clear_footertext() {
  _impl_.footertext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ButtonsMessage::footertext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.footerText)
  return _internal_footertext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsMessage::set_footertext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.footertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.footerText)
}
inline std::string* Message_ButtonsMessage::mutable_footertext() {
  std::string* _s = _internal_mutable_footertext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.footerText)
  return _s;
}
inline const std::string& Message_ButtonsMessage::_internal_footertext() const {
  return _impl_.footertext_.Get();
}
inline void Message_ButtonsMessage::_internal_set_footertext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.footertext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::_internal_mutable_footertext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.footertext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::release_footertext() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.footerText)
  if (!_internal_has_footertext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.footertext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footertext_.IsDefault()) {
    _impl_.footertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsMessage::set_allocated_footertext(std::string* footertext) {
  if (footertext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footertext_.IsDefault()) {
    _impl_.footertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.footerText)
}

// optional .proto.ContextInfo contextInfo = 8;
inline bool Message_ButtonsMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ButtonsMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ButtonsMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ContextInfo& Message_ButtonsMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ButtonsMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ButtonsMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ButtonsMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ButtonsMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ButtonsMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ButtonsMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.contextInfo)
  return _msg;
}
inline void Message_ButtonsMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.contextInfo)
}

// repeated .proto.Message.ButtonsMessage.Button buttons = 9;
inline int Message_ButtonsMessage::_internal_buttons_size() const {
  return _impl_.buttons_.size();
}
inline int Message_ButtonsMessage::buttons_size() const {
  return _internal_buttons_size();
}
inline void Message_ButtonsMessage::clear_buttons() {
  _impl_.buttons_.Clear();
}
inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::mutable_buttons(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.buttons)
  return _impl_.buttons_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >*
Message_ButtonsMessage::mutable_buttons() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ButtonsMessage.buttons)
  return &_impl_.buttons_;
}
inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::_internal_buttons(int index) const {
  return _impl_.buttons_.Get(index);
}
inline const ::proto::Message_ButtonsMessage_Button& Message_ButtonsMessage::buttons(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.buttons)
  return _internal_buttons(index);
}
inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::_internal_add_buttons() {
  return _impl_.buttons_.Add();
}
inline ::proto::Message_ButtonsMessage_Button* Message_ButtonsMessage::add_buttons() {
  ::proto::Message_ButtonsMessage_Button* _add = _internal_add_buttons();
  // @@protoc_insertion_point(field_add:proto.Message.ButtonsMessage.buttons)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ButtonsMessage_Button >&
Message_ButtonsMessage::buttons() const {
  // @@protoc_insertion_point(field_list:proto.Message.ButtonsMessage.buttons)
  return _impl_.buttons_;
}

// optional .proto.Message.ButtonsMessage.HeaderType headerType = 10;
inline bool Message_ButtonsMessage::_internal_has_headertype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ButtonsMessage::has_headertype() const {
  return _internal_has_headertype();
}
inline void Message_ButtonsMessage::clear_headertype() {
  _impl_.headertype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::_internal_headertype() const {
  return static_cast< ::proto::Message_ButtonsMessage_HeaderType >(_impl_.headertype_);
}
inline ::proto::Message_ButtonsMessage_HeaderType Message_ButtonsMessage::headertype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.headerType)
  return _internal_headertype();
}
inline void Message_ButtonsMessage::_internal_set_headertype(::proto::Message_ButtonsMessage_HeaderType value) {
  assert(::proto::Message_ButtonsMessage_HeaderType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.headertype_ = value;
}
inline void Message_ButtonsMessage::set_headertype(::proto::Message_ButtonsMessage_HeaderType value) {
  _internal_set_headertype(value);
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.headerType)
}

// string text = 1;
inline bool Message_ButtonsMessage::_internal_has_text() const {
  return header_case() == kText;
}
inline bool Message_ButtonsMessage::has_text() const {
  return _internal_has_text();
}
inline void Message_ButtonsMessage::set_has_text() {
  _impl_._oneof_case_[0] = kText;
}
inline void Message_ButtonsMessage::clear_text() {
  if (_internal_has_text()) {
    _impl_.header_.text_.Destroy();
    clear_has_header();
  }
}
inline const std::string& Message_ButtonsMessage::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline void Message_ButtonsMessage::set_text(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_text()) {
    clear_header();
    set_has_text();
    _impl_.header_.text_.InitDefault();
  }
  _impl_.header_.text_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsMessage.text)
}
inline std::string* Message_ButtonsMessage::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.text)
  return _s;
}
inline const std::string& Message_ButtonsMessage::_internal_text() const {
  if (_internal_has_text()) {
    return _impl_.header_.text_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Message_ButtonsMessage::_internal_set_text(const std::string& value) {
  if (!_internal_has_text()) {
    clear_header();
    set_has_text();
    _impl_.header_.text_.InitDefault();
  }
  _impl_.header_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::_internal_mutable_text() {
  if (!_internal_has_text()) {
    clear_header();
    set_has_text();
    _impl_.header_.text_.InitDefault();
  }
  return _impl_.header_.text_.Mutable(      GetArenaForAllocation());
}
inline std::string* Message_ButtonsMessage::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.text)
  if (_internal_has_text()) {
    clear_has_header();
    return _impl_.header_.text_.Release();
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsMessage::set_allocated_text(std::string* text) {
  if (has_header()) {
    clear_header();
  }
  if (text != nullptr) {
    set_has_text();
    _impl_.header_.text_.InitAllocated(text, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsMessage.text)
}

// .proto.Message.DocumentMessage documentMessage = 2;
inline bool Message_ButtonsMessage::_internal_has_documentmessage() const {
  return header_case() == kDocumentMessage;
}
inline bool Message_ButtonsMessage::has_documentmessage() const {
  return _internal_has_documentmessage();
}
inline void Message_ButtonsMessage::set_has_documentmessage() {
  _impl_._oneof_case_[0] = kDocumentMessage;
}
inline void Message_ButtonsMessage::clear_documentmessage() {
  if (_internal_has_documentmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.header_.documentmessage_;
    }
    clear_has_header();
  }
}
inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::release_documentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_header();
    ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.header_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::_internal_documentmessage() const {
  return _internal_has_documentmessage()
      ? *_impl_.header_.documentmessage_
      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
}
inline const ::proto::Message_DocumentMessage& Message_ButtonsMessage::documentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.documentMessage)
  return _internal_documentmessage();
}
inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::unsafe_arena_release_documentmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_header();
    ::proto::Message_DocumentMessage* temp = _impl_.header_.documentmessage_;
    _impl_.header_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsMessage::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
  clear_header();
  if (documentmessage) {
    set_has_documentmessage();
    _impl_.header_.documentmessage_ = documentmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.documentMessage)
}
inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::_internal_mutable_documentmessage() {
  if (!_internal_has_documentmessage()) {
    clear_header();
    set_has_documentmessage();
    _impl_.header_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
  }
  return _impl_.header_.documentmessage_;
}
inline ::proto::Message_DocumentMessage* Message_ButtonsMessage::mutable_documentmessage() {
  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.documentMessage)
  return _msg;
}

// .proto.Message.ImageMessage imageMessage = 3;
inline bool Message_ButtonsMessage::_internal_has_imagemessage() const {
  return header_case() == kImageMessage;
}
inline bool Message_ButtonsMessage::has_imagemessage() const {
  return _internal_has_imagemessage();
}
inline void Message_ButtonsMessage::set_has_imagemessage() {
  _impl_._oneof_case_[0] = kImageMessage;
}
inline void Message_ButtonsMessage::clear_imagemessage() {
  if (_internal_has_imagemessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.header_.imagemessage_;
    }
    clear_has_header();
  }
}
inline ::proto::Message_ImageMessage* Message_ButtonsMessage::release_imagemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_header();
    ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.header_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::_internal_imagemessage() const {
  return _internal_has_imagemessage()
      ? *_impl_.header_.imagemessage_
      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_ButtonsMessage::imagemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.imageMessage)
  return _internal_imagemessage();
}
inline ::proto::Message_ImageMessage* Message_ButtonsMessage::unsafe_arena_release_imagemessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_header();
    ::proto::Message_ImageMessage* temp = _impl_.header_.imagemessage_;
    _impl_.header_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsMessage::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
  clear_header();
  if (imagemessage) {
    set_has_imagemessage();
    _impl_.header_.imagemessage_ = imagemessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.imageMessage)
}
inline ::proto::Message_ImageMessage* Message_ButtonsMessage::_internal_mutable_imagemessage() {
  if (!_internal_has_imagemessage()) {
    clear_header();
    set_has_imagemessage();
    _impl_.header_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
  }
  return _impl_.header_.imagemessage_;
}
inline ::proto::Message_ImageMessage* Message_ButtonsMessage::mutable_imagemessage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.imageMessage)
  return _msg;
}

// .proto.Message.VideoMessage videoMessage = 4;
inline bool Message_ButtonsMessage::_internal_has_videomessage() const {
  return header_case() == kVideoMessage;
}
inline bool Message_ButtonsMessage::has_videomessage() const {
  return _internal_has_videomessage();
}
inline void Message_ButtonsMessage::set_has_videomessage() {
  _impl_._oneof_case_[0] = kVideoMessage;
}
inline void Message_ButtonsMessage::clear_videomessage() {
  if (_internal_has_videomessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.header_.videomessage_;
    }
    clear_has_header();
  }
}
inline ::proto::Message_VideoMessage* Message_ButtonsMessage::release_videomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_header();
    ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.header_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::_internal_videomessage() const {
  return _internal_has_videomessage()
      ? *_impl_.header_.videomessage_
      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
}
inline const ::proto::Message_VideoMessage& Message_ButtonsMessage::videomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.videoMessage)
  return _internal_videomessage();
}
inline ::proto::Message_VideoMessage* Message_ButtonsMessage::unsafe_arena_release_videomessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_header();
    ::proto::Message_VideoMessage* temp = _impl_.header_.videomessage_;
    _impl_.header_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsMessage::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
  clear_header();
  if (videomessage) {
    set_has_videomessage();
    _impl_.header_.videomessage_ = videomessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.videoMessage)
}
inline ::proto::Message_VideoMessage* Message_ButtonsMessage::_internal_mutable_videomessage() {
  if (!_internal_has_videomessage()) {
    clear_header();
    set_has_videomessage();
    _impl_.header_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
  }
  return _impl_.header_.videomessage_;
}
inline ::proto::Message_VideoMessage* Message_ButtonsMessage::mutable_videomessage() {
  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.videoMessage)
  return _msg;
}

// .proto.Message.LocationMessage locationMessage = 5;
inline bool Message_ButtonsMessage::_internal_has_locationmessage() const {
  return header_case() == kLocationMessage;
}
inline bool Message_ButtonsMessage::has_locationmessage() const {
  return _internal_has_locationmessage();
}
inline void Message_ButtonsMessage::set_has_locationmessage() {
  _impl_._oneof_case_[0] = kLocationMessage;
}
inline void Message_ButtonsMessage::clear_locationmessage() {
  if (_internal_has_locationmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.header_.locationmessage_;
    }
    clear_has_header();
  }
}
inline ::proto::Message_LocationMessage* Message_ButtonsMessage::release_locationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsMessage.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_header();
    ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.header_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::_internal_locationmessage() const {
  return _internal_has_locationmessage()
      ? *_impl_.header_.locationmessage_
      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
}
inline const ::proto::Message_LocationMessage& Message_ButtonsMessage::locationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsMessage.locationMessage)
  return _internal_locationmessage();
}
inline ::proto::Message_LocationMessage* Message_ButtonsMessage::unsafe_arena_release_locationmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.ButtonsMessage.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_header();
    ::proto::Message_LocationMessage* temp = _impl_.header_.locationmessage_;
    _impl_.header_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsMessage::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
  clear_header();
  if (locationmessage) {
    set_has_locationmessage();
    _impl_.header_.locationmessage_ = locationmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsMessage.locationMessage)
}
inline ::proto::Message_LocationMessage* Message_ButtonsMessage::_internal_mutable_locationmessage() {
  if (!_internal_has_locationmessage()) {
    clear_header();
    set_has_locationmessage();
    _impl_.header_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
  }
  return _impl_.header_.locationmessage_;
}
inline ::proto::Message_LocationMessage* Message_ButtonsMessage::mutable_locationmessage() {
  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsMessage.locationMessage)
  return _msg;
}

inline bool Message_ButtonsMessage::has_header() const {
  return header_case() != HEADER_NOT_SET;
}
inline void Message_ButtonsMessage::clear_has_header() {
  _impl_._oneof_case_[0] = HEADER_NOT_SET;
}
inline Message_ButtonsMessage::HeaderCase Message_ButtonsMessage::header_case() const {
  return Message_ButtonsMessage::HeaderCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_ButtonsResponseMessage

// optional string selectedButtonId = 1;
inline bool Message_ButtonsResponseMessage::_internal_has_selectedbuttonid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ButtonsResponseMessage::has_selectedbuttonid() const {
  return _internal_has_selectedbuttonid();
}
inline void Message_ButtonsResponseMessage::clear_selectedbuttonid() {
  _impl_.selectedbuttonid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ButtonsResponseMessage::selectedbuttonid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedButtonId)
  return _internal_selectedbuttonid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ButtonsResponseMessage::set_selectedbuttonid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.selectedbuttonid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedButtonId)
}
inline std::string* Message_ButtonsResponseMessage::mutable_selectedbuttonid() {
  std::string* _s = _internal_mutable_selectedbuttonid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedButtonId)
  return _s;
}
inline const std::string& Message_ButtonsResponseMessage::_internal_selectedbuttonid() const {
  return _impl_.selectedbuttonid_.Get();
}
inline void Message_ButtonsResponseMessage::_internal_set_selectedbuttonid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.selectedbuttonid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selectedbuttonid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.selectedbuttonid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ButtonsResponseMessage::release_selectedbuttonid() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedButtonId)
  if (!_internal_has_selectedbuttonid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.selectedbuttonid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedbuttonid_.IsDefault()) {
    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ButtonsResponseMessage::set_allocated_selectedbuttonid(std::string* selectedbuttonid) {
  if (selectedbuttonid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.selectedbuttonid_.SetAllocated(selectedbuttonid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedbuttonid_.IsDefault()) {
    _impl_.selectedbuttonid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedButtonId)
}

// optional .proto.ContextInfo contextInfo = 3;
inline bool Message_ButtonsResponseMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ButtonsResponseMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ButtonsResponseMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ButtonsResponseMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ButtonsResponseMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ButtonsResponseMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ButtonsResponseMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ButtonsResponseMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ButtonsResponseMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.contextInfo)
  return _msg;
}
inline void Message_ButtonsResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.contextInfo)
}

// optional .proto.Message.ButtonsResponseMessage.Type type = 4;
inline bool Message_ButtonsResponseMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ButtonsResponseMessage::has_type() const {
  return _internal_has_type();
}
inline void Message_ButtonsResponseMessage::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::_internal_type() const {
  return static_cast< ::proto::Message_ButtonsResponseMessage_Type >(_impl_.type_);
}
inline ::proto::Message_ButtonsResponseMessage_Type Message_ButtonsResponseMessage::type() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.type)
  return _internal_type();
}
inline void Message_ButtonsResponseMessage::_internal_set_type(::proto::Message_ButtonsResponseMessage_Type value) {
  assert(::proto::Message_ButtonsResponseMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.type_ = value;
}
inline void Message_ButtonsResponseMessage::set_type(::proto::Message_ButtonsResponseMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.type)
}

// string selectedDisplayText = 2;
inline bool Message_ButtonsResponseMessage::_internal_has_selecteddisplaytext() const {
  return response_case() == kSelectedDisplayText;
}
inline bool Message_ButtonsResponseMessage::has_selecteddisplaytext() const {
  return _internal_has_selecteddisplaytext();
}
inline void Message_ButtonsResponseMessage::set_has_selecteddisplaytext() {
  _impl_._oneof_case_[0] = kSelectedDisplayText;
}
inline void Message_ButtonsResponseMessage::clear_selecteddisplaytext() {
  if (_internal_has_selecteddisplaytext()) {
    _impl_.response_.selecteddisplaytext_.Destroy();
    clear_has_response();
  }
}
inline const std::string& Message_ButtonsResponseMessage::selecteddisplaytext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ButtonsResponseMessage.selectedDisplayText)
  return _internal_selecteddisplaytext();
}
template <typename ArgT0, typename... ArgT>
inline void Message_ButtonsResponseMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_selecteddisplaytext()) {
    clear_response();
    set_has_selecteddisplaytext();
    _impl_.response_.selecteddisplaytext_.InitDefault();
  }
  _impl_.response_.selecteddisplaytext_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ButtonsResponseMessage.selectedDisplayText)
}
inline std::string* Message_ButtonsResponseMessage::mutable_selecteddisplaytext() {
  std::string* _s = _internal_mutable_selecteddisplaytext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ButtonsResponseMessage.selectedDisplayText)
  return _s;
}
inline const std::string& Message_ButtonsResponseMessage::_internal_selecteddisplaytext() const {
  if (_internal_has_selecteddisplaytext()) {
    return _impl_.response_.selecteddisplaytext_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Message_ButtonsResponseMessage::_internal_set_selecteddisplaytext(const std::string& value) {
  if (!_internal_has_selecteddisplaytext()) {
    clear_response();
    set_has_selecteddisplaytext();
    _impl_.response_.selecteddisplaytext_.InitDefault();
  }
  _impl_.response_.selecteddisplaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ButtonsResponseMessage::_internal_mutable_selecteddisplaytext() {
  if (!_internal_has_selecteddisplaytext()) {
    clear_response();
    set_has_selecteddisplaytext();
    _impl_.response_.selecteddisplaytext_.InitDefault();
  }
  return _impl_.response_.selecteddisplaytext_.Mutable(      GetArenaForAllocation());
}
inline std::string* Message_ButtonsResponseMessage::release_selecteddisplaytext() {
  // @@protoc_insertion_point(field_release:proto.Message.ButtonsResponseMessage.selectedDisplayText)
  if (_internal_has_selecteddisplaytext()) {
    clear_has_response();
    return _impl_.response_.selecteddisplaytext_.Release();
  } else {
    return nullptr;
  }
}
inline void Message_ButtonsResponseMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) {
  if (has_response()) {
    clear_response();
  }
  if (selecteddisplaytext != nullptr) {
    set_has_selecteddisplaytext();
    _impl_.response_.selecteddisplaytext_.InitAllocated(selecteddisplaytext, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ButtonsResponseMessage.selectedDisplayText)
}

inline bool Message_ButtonsResponseMessage::has_response() const {
  return response_case() != RESPONSE_NOT_SET;
}
inline void Message_ButtonsResponseMessage::clear_has_response() {
  _impl_._oneof_case_[0] = RESPONSE_NOT_SET;
}
inline Message_ButtonsResponseMessage::ResponseCase Message_ButtonsResponseMessage::response_case() const {
  return Message_ButtonsResponseMessage::ResponseCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_Call

// optional bytes callKey = 1;
inline bool Message_Call::_internal_has_callkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_Call::has_callkey() const {
  return _internal_has_callkey();
}
inline void Message_Call::clear_callkey() {
  _impl_.callkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_Call::callkey() const {
  // @@protoc_insertion_point(field_get:proto.Message.Call.callKey)
  return _internal_callkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_Call::set_callkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.callkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.Call.callKey)
}
inline std::string* Message_Call::mutable_callkey() {
  std::string* _s = _internal_mutable_callkey();
  // @@protoc_insertion_point(field_mutable:proto.Message.Call.callKey)
  return _s;
}
inline const std::string& Message_Call::_internal_callkey() const {
  return _impl_.callkey_.Get();
}
inline void Message_Call::_internal_set_callkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.callkey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_Call::_internal_mutable_callkey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.callkey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_Call::release_callkey() {
  // @@protoc_insertion_point(field_release:proto.Message.Call.callKey)
  if (!_internal_has_callkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.callkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.callkey_.IsDefault()) {
    _impl_.callkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_Call::set_allocated_callkey(std::string* callkey) {
  if (callkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.callkey_.SetAllocated(callkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.callkey_.IsDefault()) {
    _impl_.callkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.callKey)
}

// optional string conversionSource = 2;
inline bool Message_Call::_internal_has_conversionsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_Call::has_conversionsource() const {
  return _internal_has_conversionsource();
}
inline void Message_Call::clear_conversionsource() {
  _impl_.conversionsource_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_Call::conversionsource() const {
  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionSource)
  return _internal_conversionsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_Call::set_conversionsource(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.conversionsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionSource)
}
inline std::string* Message_Call::mutable_conversionsource() {
  std::string* _s = _internal_mutable_conversionsource();
  // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionSource)
  return _s;
}
inline const std::string& Message_Call::_internal_conversionsource() const {
  return _impl_.conversionsource_.Get();
}
inline void Message_Call::_internal_set_conversionsource(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.conversionsource_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_Call::_internal_mutable_conversionsource() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.conversionsource_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_Call::release_conversionsource() {
  // @@protoc_insertion_point(field_release:proto.Message.Call.conversionSource)
  if (!_internal_has_conversionsource()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.conversionsource_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversionsource_.IsDefault()) {
    _impl_.conversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_Call::set_allocated_conversionsource(std::string* conversionsource) {
  if (conversionsource != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.conversionsource_.SetAllocated(conversionsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversionsource_.IsDefault()) {
    _impl_.conversionsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionSource)
}

// optional bytes conversionData = 3;
inline bool Message_Call::_internal_has_conversiondata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_Call::has_conversiondata() const {
  return _internal_has_conversiondata();
}
inline void Message_Call::clear_conversiondata() {
  _impl_.conversiondata_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_Call::conversiondata() const {
  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionData)
  return _internal_conversiondata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_Call::set_conversiondata(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.conversiondata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionData)
}
inline std::string* Message_Call::mutable_conversiondata() {
  std::string* _s = _internal_mutable_conversiondata();
  // @@protoc_insertion_point(field_mutable:proto.Message.Call.conversionData)
  return _s;
}
inline const std::string& Message_Call::_internal_conversiondata() const {
  return _impl_.conversiondata_.Get();
}
inline void Message_Call::_internal_set_conversiondata(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.conversiondata_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_Call::_internal_mutable_conversiondata() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.conversiondata_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_Call::release_conversiondata() {
  // @@protoc_insertion_point(field_release:proto.Message.Call.conversionData)
  if (!_internal_has_conversiondata()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.conversiondata_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversiondata_.IsDefault()) {
    _impl_.conversiondata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_Call::set_allocated_conversiondata(std::string* conversiondata) {
  if (conversiondata != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.conversiondata_.SetAllocated(conversiondata, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversiondata_.IsDefault()) {
    _impl_.conversiondata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.Call.conversionData)
}

// optional uint32 conversionDelaySeconds = 4;
inline bool Message_Call::_internal_has_conversiondelayseconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_Call::has_conversiondelayseconds() const {
  return _internal_has_conversiondelayseconds();
}
inline void Message_Call::clear_conversiondelayseconds() {
  _impl_.conversiondelayseconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Message_Call::_internal_conversiondelayseconds() const {
  return _impl_.conversiondelayseconds_;
}
inline uint32_t Message_Call::conversiondelayseconds() const {
  // @@protoc_insertion_point(field_get:proto.Message.Call.conversionDelaySeconds)
  return _internal_conversiondelayseconds();
}
inline void Message_Call::_internal_set_conversiondelayseconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.conversiondelayseconds_ = value;
}
inline void Message_Call::set_conversiondelayseconds(uint32_t value) {
  _internal_set_conversiondelayseconds(value);
  // @@protoc_insertion_point(field_set:proto.Message.Call.conversionDelaySeconds)
}

// -------------------------------------------------------------------

// Message_CancelPaymentRequestMessage

// optional .proto.MessageKey key = 1;
inline bool Message_CancelPaymentRequestMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Message_CancelPaymentRequestMessage::has_key() const {
  return _internal_has_key();
}
inline void Message_CancelPaymentRequestMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_CancelPaymentRequestMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.Message.CancelPaymentRequestMessage.key)
  return _internal_key();
}
inline void Message_CancelPaymentRequestMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.CancelPaymentRequestMessage.key)
}
inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Message_CancelPaymentRequestMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Message.CancelPaymentRequestMessage.key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Message_CancelPaymentRequestMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Message.CancelPaymentRequestMessage.key)
  return _msg;
}
inline void Message_CancelPaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.CancelPaymentRequestMessage.key)
}

// -------------------------------------------------------------------

// Message_Chat

// optional string displayName = 1;
inline bool Message_Chat::_internal_has_displayname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_Chat::has_displayname() const {
  return _internal_has_displayname();
}
inline void Message_Chat::clear_displayname() {
  _impl_.displayname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_Chat::displayname() const {
  // @@protoc_insertion_point(field_get:proto.Message.Chat.displayName)
  return _internal_displayname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_Chat::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:proto.Message.Chat.displayName)
}
inline std::string* Message_Chat::mutable_displayname() {
  std::string* _s = _internal_mutable_displayname();
  // @@protoc_insertion_point(field_mutable:proto.Message.Chat.displayName)
  return _s;
}
inline const std::string& Message_Chat::_internal_displayname() const {
  return _impl_.displayname_.Get();
}
inline void Message_Chat::_internal_set_displayname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displayname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_Chat::_internal_mutable_displayname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displayname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_Chat::release_displayname() {
  // @@protoc_insertion_point(field_release:proto.Message.Chat.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 Message_Chat::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:proto.Message.Chat.displayName)
}

// optional string id = 2;
inline bool Message_Chat::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_Chat::has_id() const {
  return _internal_has_id();
}
inline void Message_Chat::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_Chat::id() const {
  // @@protoc_insertion_point(field_get:proto.Message.Chat.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_Chat::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.Chat.id)
}
inline std::string* Message_Chat::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.Message.Chat.id)
  return _s;
}
inline const std::string& Message_Chat::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Message_Chat::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_Chat::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_Chat::release_id() {
  // @@protoc_insertion_point(field_release:proto.Message.Chat.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_Chat::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.Chat.id)
}

// -------------------------------------------------------------------

// Message_ContactMessage

// optional string displayName = 1;
inline bool Message_ContactMessage::_internal_has_displayname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ContactMessage::has_displayname() const {
  return _internal_has_displayname();
}
inline void Message_ContactMessage::clear_displayname() {
  _impl_.displayname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ContactMessage::displayname() const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.displayName)
  return _internal_displayname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ContactMessage::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:proto.Message.ContactMessage.displayName)
}
inline std::string* Message_ContactMessage::mutable_displayname() {
  std::string* _s = _internal_mutable_displayname();
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.displayName)
  return _s;
}
inline const std::string& Message_ContactMessage::_internal_displayname() const {
  return _impl_.displayname_.Get();
}
inline void Message_ContactMessage::_internal_set_displayname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displayname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ContactMessage::_internal_mutable_displayname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displayname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ContactMessage::release_displayname() {
  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.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 Message_ContactMessage::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:proto.Message.ContactMessage.displayName)
}

// optional string vcard = 16;
inline bool Message_ContactMessage::_internal_has_vcard() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ContactMessage::has_vcard() const {
  return _internal_has_vcard();
}
inline void Message_ContactMessage::clear_vcard() {
  _impl_.vcard_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ContactMessage::vcard() const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.vcard)
  return _internal_vcard();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ContactMessage::set_vcard(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.vcard_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ContactMessage.vcard)
}
inline std::string* Message_ContactMessage::mutable_vcard() {
  std::string* _s = _internal_mutable_vcard();
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.vcard)
  return _s;
}
inline const std::string& Message_ContactMessage::_internal_vcard() const {
  return _impl_.vcard_.Get();
}
inline void Message_ContactMessage::_internal_set_vcard(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.vcard_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ContactMessage::_internal_mutable_vcard() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.vcard_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ContactMessage::release_vcard() {
  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.vcard)
  if (!_internal_has_vcard()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.vcard_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vcard_.IsDefault()) {
    _impl_.vcard_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ContactMessage::set_allocated_vcard(std::string* vcard) {
  if (vcard != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.vcard_.SetAllocated(vcard, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.vcard_.IsDefault()) {
    _impl_.vcard_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.vcard)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_ContactMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ContactMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ContactMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ContextInfo& Message_ContactMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ContactMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ContactMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ContactMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ContactMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ContactMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ContactMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ContactMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactMessage.contextInfo)
  return _msg;
}
inline void Message_ContactMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_ContactsArrayMessage

// optional string displayName = 1;
inline bool Message_ContactsArrayMessage::_internal_has_displayname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ContactsArrayMessage::has_displayname() const {
  return _internal_has_displayname();
}
inline void Message_ContactsArrayMessage::clear_displayname() {
  _impl_.displayname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ContactsArrayMessage::displayname() const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.displayName)
  return _internal_displayname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ContactsArrayMessage::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:proto.Message.ContactsArrayMessage.displayName)
}
inline std::string* Message_ContactsArrayMessage::mutable_displayname() {
  std::string* _s = _internal_mutable_displayname();
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.displayName)
  return _s;
}
inline const std::string& Message_ContactsArrayMessage::_internal_displayname() const {
  return _impl_.displayname_.Get();
}
inline void Message_ContactsArrayMessage::_internal_set_displayname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.displayname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ContactsArrayMessage::_internal_mutable_displayname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.displayname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ContactsArrayMessage::release_displayname() {
  // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.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 Message_ContactsArrayMessage::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:proto.Message.ContactsArrayMessage.displayName)
}

// repeated .proto.Message.ContactMessage contacts = 2;
inline int Message_ContactsArrayMessage::_internal_contacts_size() const {
  return _impl_.contacts_.size();
}
inline int Message_ContactsArrayMessage::contacts_size() const {
  return _internal_contacts_size();
}
inline void Message_ContactsArrayMessage::clear_contacts() {
  _impl_.contacts_.Clear();
}
inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::mutable_contacts(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contacts)
  return _impl_.contacts_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >*
Message_ContactsArrayMessage::mutable_contacts() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ContactsArrayMessage.contacts)
  return &_impl_.contacts_;
}
inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::_internal_contacts(int index) const {
  return _impl_.contacts_.Get(index);
}
inline const ::proto::Message_ContactMessage& Message_ContactsArrayMessage::contacts(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contacts)
  return _internal_contacts(index);
}
inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::_internal_add_contacts() {
  return _impl_.contacts_.Add();
}
inline ::proto::Message_ContactMessage* Message_ContactsArrayMessage::add_contacts() {
  ::proto::Message_ContactMessage* _add = _internal_add_contacts();
  // @@protoc_insertion_point(field_add:proto.Message.ContactsArrayMessage.contacts)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ContactMessage >&
Message_ContactsArrayMessage::contacts() const {
  // @@protoc_insertion_point(field_list:proto.Message.ContactsArrayMessage.contacts)
  return _impl_.contacts_;
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_ContactsArrayMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ContactsArrayMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ContactsArrayMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::ContextInfo& Message_ContactsArrayMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ContactsArrayMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ContactsArrayMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ContactsArrayMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ContactsArrayMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ContactsArrayMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ContactsArrayMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ContactsArrayMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ContactsArrayMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ContactsArrayMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ContactsArrayMessage.contextInfo)
  return _msg;
}
inline void Message_ContactsArrayMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ContactsArrayMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_DeclinePaymentRequestMessage

// optional .proto.MessageKey key = 1;
inline bool Message_DeclinePaymentRequestMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Message_DeclinePaymentRequestMessage::has_key() const {
  return _internal_has_key();
}
inline void Message_DeclinePaymentRequestMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_DeclinePaymentRequestMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.Message.DeclinePaymentRequestMessage.key)
  return _internal_key();
}
inline void Message_DeclinePaymentRequestMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeclinePaymentRequestMessage.key)
}
inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Message_DeclinePaymentRequestMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Message.DeclinePaymentRequestMessage.key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Message_DeclinePaymentRequestMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Message.DeclinePaymentRequestMessage.key)
  return _msg;
}
inline void Message_DeclinePaymentRequestMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeclinePaymentRequestMessage.key)
}

// -------------------------------------------------------------------

// Message_DeviceSentMessage

// optional string destinationJid = 1;
inline bool Message_DeviceSentMessage::_internal_has_destinationjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_DeviceSentMessage::has_destinationjid() const {
  return _internal_has_destinationjid();
}
inline void Message_DeviceSentMessage::clear_destinationjid() {
  _impl_.destinationjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_DeviceSentMessage::destinationjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.destinationJid)
  return _internal_destinationjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DeviceSentMessage::set_destinationjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.destinationjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.destinationJid)
}
inline std::string* Message_DeviceSentMessage::mutable_destinationjid() {
  std::string* _s = _internal_mutable_destinationjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.destinationJid)
  return _s;
}
inline const std::string& Message_DeviceSentMessage::_internal_destinationjid() const {
  return _impl_.destinationjid_.Get();
}
inline void Message_DeviceSentMessage::_internal_set_destinationjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.destinationjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DeviceSentMessage::_internal_mutable_destinationjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.destinationjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DeviceSentMessage::release_destinationjid() {
  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.destinationJid)
  if (!_internal_has_destinationjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.destinationjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.destinationjid_.IsDefault()) {
    _impl_.destinationjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DeviceSentMessage::set_allocated_destinationjid(std::string* destinationjid) {
  if (destinationjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.destinationjid_.SetAllocated(destinationjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.destinationjid_.IsDefault()) {
    _impl_.destinationjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.destinationJid)
}

// optional .proto.Message message = 2;
inline bool Message_DeviceSentMessage::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
  return value;
}
inline bool Message_DeviceSentMessage::has_message() const {
  return _internal_has_message();
}
inline void Message_DeviceSentMessage::clear_message() {
  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message& Message_DeviceSentMessage::_internal_message() const {
  const ::proto::Message* p = _impl_.message_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& Message_DeviceSentMessage::message() const {
  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.message)
  return _internal_message();
}
inline void Message_DeviceSentMessage::unsafe_arena_set_allocated_message(
    ::proto::Message* message) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
  }
  _impl_.message_ = message;
  if (message) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DeviceSentMessage.message)
}
inline ::proto::Message* Message_DeviceSentMessage::release_message() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = 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 ::proto::Message* Message_DeviceSentMessage::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.message)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = nullptr;
  return temp;
}
inline ::proto::Message* Message_DeviceSentMessage::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.message_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.message_ = p;
  }
  return _impl_.message_;
}
inline ::proto::Message* Message_DeviceSentMessage::mutable_message() {
  ::proto::Message* _msg = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.message)
  return _msg;
}
inline void Message_DeviceSentMessage::set_allocated_message(::proto::Message* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.message_ = message;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.message)
}

// optional string phash = 3;
inline bool Message_DeviceSentMessage::_internal_has_phash() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_DeviceSentMessage::has_phash() const {
  return _internal_has_phash();
}
inline void Message_DeviceSentMessage::clear_phash() {
  _impl_.phash_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_DeviceSentMessage::phash() const {
  // @@protoc_insertion_point(field_get:proto.Message.DeviceSentMessage.phash)
  return _internal_phash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DeviceSentMessage::set_phash(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.phash_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DeviceSentMessage.phash)
}
inline std::string* Message_DeviceSentMessage::mutable_phash() {
  std::string* _s = _internal_mutable_phash();
  // @@protoc_insertion_point(field_mutable:proto.Message.DeviceSentMessage.phash)
  return _s;
}
inline const std::string& Message_DeviceSentMessage::_internal_phash() const {
  return _impl_.phash_.Get();
}
inline void Message_DeviceSentMessage::_internal_set_phash(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.phash_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DeviceSentMessage::_internal_mutable_phash() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.phash_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DeviceSentMessage::release_phash() {
  // @@protoc_insertion_point(field_release:proto.Message.DeviceSentMessage.phash)
  if (!_internal_has_phash()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.phash_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phash_.IsDefault()) {
    _impl_.phash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DeviceSentMessage::set_allocated_phash(std::string* phash) {
  if (phash != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.phash_.SetAllocated(phash, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.phash_.IsDefault()) {
    _impl_.phash_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DeviceSentMessage.phash)
}

// -------------------------------------------------------------------

// Message_DocumentMessage

// optional string url = 1;
inline bool Message_DocumentMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_DocumentMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_DocumentMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::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:proto.Message.DocumentMessage.url)
}
inline std::string* Message_DocumentMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.url)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_DocumentMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.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 Message_DocumentMessage::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:proto.Message.DocumentMessage.url)
}

// optional string mimetype = 2;
inline bool Message_DocumentMessage::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void Message_DocumentMessage::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_DocumentMessage::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mimetype)
}
inline std::string* Message_DocumentMessage::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mimetype)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void Message_DocumentMessage::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mimetype)
}

// optional string title = 3;
inline bool Message_DocumentMessage::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_title() const {
  return _internal_has_title();
}
inline void Message_DocumentMessage::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_DocumentMessage::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.title)
}
inline std::string* Message_DocumentMessage::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.title)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_DocumentMessage::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  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 Message_DocumentMessage::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _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:proto.Message.DocumentMessage.title)
}

// optional bytes fileSha256 = 4;
inline bool Message_DocumentMessage::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_DocumentMessage::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_DocumentMessage::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileSha256)
}
inline std::string* Message_DocumentMessage::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileSha256)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_DocumentMessage::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileSha256)
}

// optional uint64 fileLength = 5;
inline bool Message_DocumentMessage::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_DocumentMessage::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t Message_DocumentMessage::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_DocumentMessage::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileLength)
  return _internal_filelength();
}
inline void Message_DocumentMessage::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.filelength_ = value;
}
inline void Message_DocumentMessage::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileLength)
}

// optional uint32 pageCount = 6;
inline bool Message_DocumentMessage::_internal_has_pagecount() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_pagecount() const {
  return _internal_has_pagecount();
}
inline void Message_DocumentMessage::clear_pagecount() {
  _impl_.pagecount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t Message_DocumentMessage::_internal_pagecount() const {
  return _impl_.pagecount_;
}
inline uint32_t Message_DocumentMessage::pagecount() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.pageCount)
  return _internal_pagecount();
}
inline void Message_DocumentMessage::_internal_set_pagecount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.pagecount_ = value;
}
inline void Message_DocumentMessage::set_pagecount(uint32_t value) {
  _internal_set_pagecount(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.pageCount)
}

// optional bytes mediaKey = 7;
inline bool Message_DocumentMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_DocumentMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_DocumentMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKey)
}
inline std::string* Message_DocumentMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.mediaKey)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_DocumentMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.mediaKey)
}

// optional string fileName = 8;
inline bool Message_DocumentMessage::_internal_has_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_filename() const {
  return _internal_has_filename();
}
inline void Message_DocumentMessage::clear_filename() {
  _impl_.filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_DocumentMessage::filename() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileName)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_filename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileName)
}
inline std::string* Message_DocumentMessage::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileName)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void Message_DocumentMessage::_internal_set_filename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_filename() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_filename() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileName)
  if (!_internal_has_filename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  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 Message_DocumentMessage::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _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:proto.Message.DocumentMessage.fileName)
}

// optional bytes fileEncSha256 = 9;
inline bool Message_DocumentMessage::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_DocumentMessage::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_DocumentMessage::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.fileEncSha256)
}
inline std::string* Message_DocumentMessage::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.fileEncSha256)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_DocumentMessage::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.fileEncSha256)
}

// optional string directPath = 10;
inline bool Message_DocumentMessage::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_DocumentMessage::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_DocumentMessage::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.directPath)
}
inline std::string* Message_DocumentMessage::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.directPath)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_DocumentMessage::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.directPath)
}

// optional int64 mediaKeyTimestamp = 11;
inline bool Message_DocumentMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_DocumentMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int64_t Message_DocumentMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_DocumentMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_DocumentMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_DocumentMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.mediaKeyTimestamp)
}

// optional bool contactVcard = 12;
inline bool Message_DocumentMessage::_internal_has_contactvcard() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_contactvcard() const {
  return _internal_has_contactvcard();
}
inline void Message_DocumentMessage::clear_contactvcard() {
  _impl_.contactvcard_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool Message_DocumentMessage::_internal_contactvcard() const {
  return _impl_.contactvcard_;
}
inline bool Message_DocumentMessage::contactvcard() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contactVcard)
  return _internal_contactvcard();
}
inline void Message_DocumentMessage::_internal_set_contactvcard(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.contactvcard_ = value;
}
inline void Message_DocumentMessage::set_contactvcard(bool value) {
  _internal_set_contactvcard(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.contactVcard)
}

// optional string thumbnailDirectPath = 13;
inline bool Message_DocumentMessage::_internal_has_thumbnaildirectpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_thumbnaildirectpath() const {
  return _internal_has_thumbnaildirectpath();
}
inline void Message_DocumentMessage::clear_thumbnaildirectpath() {
  _impl_.thumbnaildirectpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Message_DocumentMessage::thumbnaildirectpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailDirectPath)
  return _internal_thumbnaildirectpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailDirectPath)
}
inline std::string* Message_DocumentMessage::mutable_thumbnaildirectpath() {
  std::string* _s = _internal_mutable_thumbnaildirectpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailDirectPath)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_thumbnaildirectpath() const {
  return _impl_.thumbnaildirectpath_.Get();
}
inline void Message_DocumentMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_thumbnaildirectpath() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_thumbnaildirectpath() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailDirectPath)
  if (!_internal_has_thumbnaildirectpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.thumbnaildirectpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
  if (thumbnaildirectpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailDirectPath)
}

// optional bytes thumbnailSha256 = 14;
inline bool Message_DocumentMessage::_internal_has_thumbnailsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_thumbnailsha256() const {
  return _internal_has_thumbnailsha256();
}
inline void Message_DocumentMessage::clear_thumbnailsha256() {
  _impl_.thumbnailsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Message_DocumentMessage::thumbnailsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailSha256)
  return _internal_thumbnailsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailSha256)
}
inline std::string* Message_DocumentMessage::mutable_thumbnailsha256() {
  std::string* _s = _internal_mutable_thumbnailsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailSha256)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_thumbnailsha256() const {
  return _impl_.thumbnailsha256_.Get();
}
inline void Message_DocumentMessage::_internal_set_thumbnailsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailsha256() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_thumbnailsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailSha256)
  if (!_internal_has_thumbnailsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.thumbnailsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
  if (thumbnailsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailSha256)
}

// optional bytes thumbnailEncSha256 = 15;
inline bool Message_DocumentMessage::_internal_has_thumbnailencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_thumbnailencsha256() const {
  return _internal_has_thumbnailencsha256();
}
inline void Message_DocumentMessage::clear_thumbnailencsha256() {
  _impl_.thumbnailencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Message_DocumentMessage::thumbnailencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailEncSha256)
  return _internal_thumbnailencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailEncSha256)
}
inline std::string* Message_DocumentMessage::mutable_thumbnailencsha256() {
  std::string* _s = _internal_mutable_thumbnailencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.thumbnailEncSha256)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_thumbnailencsha256() const {
  return _impl_.thumbnailencsha256_.Get();
}
inline void Message_DocumentMessage::_internal_set_thumbnailencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_thumbnailencsha256() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_thumbnailencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.thumbnailEncSha256)
  if (!_internal_has_thumbnailencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.thumbnailencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
  if (thumbnailencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.thumbnailEncSha256)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_DocumentMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_DocumentMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Message_DocumentMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.jpegThumbnail)
}
inline std::string* Message_DocumentMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_DocumentMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_DocumentMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_DocumentMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_DocumentMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_DocumentMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::ContextInfo& Message_DocumentMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_DocumentMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_DocumentMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.DocumentMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_DocumentMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_DocumentMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_DocumentMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_DocumentMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.contextInfo)
  return _msg;
}
inline void Message_DocumentMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.DocumentMessage.contextInfo)
}

// optional uint32 thumbnailHeight = 18;
inline bool Message_DocumentMessage::_internal_has_thumbnailheight() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_thumbnailheight() const {
  return _internal_has_thumbnailheight();
}
inline void Message_DocumentMessage::clear_thumbnailheight() {
  _impl_.thumbnailheight_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t Message_DocumentMessage::_internal_thumbnailheight() const {
  return _impl_.thumbnailheight_;
}
inline uint32_t Message_DocumentMessage::thumbnailheight() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailHeight)
  return _internal_thumbnailheight();
}
inline void Message_DocumentMessage::_internal_set_thumbnailheight(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.thumbnailheight_ = value;
}
inline void Message_DocumentMessage::set_thumbnailheight(uint32_t value) {
  _internal_set_thumbnailheight(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailHeight)
}

// optional uint32 thumbnailWidth = 19;
inline bool Message_DocumentMessage::_internal_has_thumbnailwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_thumbnailwidth() const {
  return _internal_has_thumbnailwidth();
}
inline void Message_DocumentMessage::clear_thumbnailwidth() {
  _impl_.thumbnailwidth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t Message_DocumentMessage::_internal_thumbnailwidth() const {
  return _impl_.thumbnailwidth_;
}
inline uint32_t Message_DocumentMessage::thumbnailwidth() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.thumbnailWidth)
  return _internal_thumbnailwidth();
}
inline void Message_DocumentMessage::_internal_set_thumbnailwidth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.thumbnailwidth_ = value;
}
inline void Message_DocumentMessage::set_thumbnailwidth(uint32_t value) {
  _internal_set_thumbnailwidth(value);
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.thumbnailWidth)
}

// optional string caption = 20;
inline bool Message_DocumentMessage::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Message_DocumentMessage::has_caption() const {
  return _internal_has_caption();
}
inline void Message_DocumentMessage::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& Message_DocumentMessage::caption() const {
  // @@protoc_insertion_point(field_get:proto.Message.DocumentMessage.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_DocumentMessage::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00001000u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.DocumentMessage.caption)
}
inline std::string* Message_DocumentMessage::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.Message.DocumentMessage.caption)
  return _s;
}
inline const std::string& Message_DocumentMessage::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void Message_DocumentMessage::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_DocumentMessage::release_caption() {
  // @@protoc_insertion_point(field_release:proto.Message.DocumentMessage.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  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 Message_DocumentMessage::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _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:proto.Message.DocumentMessage.caption)
}

// -------------------------------------------------------------------

// Message_ExtendedTextMessage

// optional string text = 1;
inline bool Message_ExtendedTextMessage::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_text() const {
  return _internal_has_text();
}
inline void Message_ExtendedTextMessage::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ExtendedTextMessage::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.text)
}
inline std::string* Message_ExtendedTextMessage::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.text)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ExtendedTextMessage::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ExtendedTextMessage.text)
}

// optional string matchedText = 2;
inline bool Message_ExtendedTextMessage::_internal_has_matchedtext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_matchedtext() const {
  return _internal_has_matchedtext();
}
inline void Message_ExtendedTextMessage::clear_matchedtext() {
  _impl_.matchedtext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ExtendedTextMessage::matchedtext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.matchedText)
  return _internal_matchedtext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_matchedtext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.matchedtext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.matchedText)
}
inline std::string* Message_ExtendedTextMessage::mutable_matchedtext() {
  std::string* _s = _internal_mutable_matchedtext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.matchedText)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_matchedtext() const {
  return _impl_.matchedtext_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_matchedtext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.matchedtext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_matchedtext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.matchedtext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_matchedtext() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.matchedText)
  if (!_internal_has_matchedtext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.matchedtext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.matchedtext_.IsDefault()) {
    _impl_.matchedtext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_matchedtext(std::string* matchedtext) {
  if (matchedtext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.matchedtext_.IsDefault()) {
    _impl_.matchedtext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.matchedText)
}

// optional string canonicalUrl = 4;
inline bool Message_ExtendedTextMessage::_internal_has_canonicalurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_canonicalurl() const {
  return _internal_has_canonicalurl();
}
inline void Message_ExtendedTextMessage::clear_canonicalurl() {
  _impl_.canonicalurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ExtendedTextMessage::canonicalurl() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.canonicalUrl)
  return _internal_canonicalurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_canonicalurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.canonicalurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.canonicalUrl)
}
inline std::string* Message_ExtendedTextMessage::mutable_canonicalurl() {
  std::string* _s = _internal_mutable_canonicalurl();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.canonicalUrl)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_canonicalurl() const {
  return _impl_.canonicalurl_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_canonicalurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.canonicalurl_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_canonicalurl() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.canonicalurl_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_canonicalurl() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.canonicalUrl)
  if (!_internal_has_canonicalurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.canonicalurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.canonicalurl_.IsDefault()) {
    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_canonicalurl(std::string* canonicalurl) {
  if (canonicalurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.canonicalurl_.IsDefault()) {
    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.canonicalUrl)
}

// optional string description = 5;
inline bool Message_ExtendedTextMessage::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_description() const {
  return _internal_has_description();
}
inline void Message_ExtendedTextMessage::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_ExtendedTextMessage::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.description)
}
inline std::string* Message_ExtendedTextMessage::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.description)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.description)
}

// optional string title = 6;
inline bool Message_ExtendedTextMessage::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_title() const {
  return _internal_has_title();
}
inline void Message_ExtendedTextMessage::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_ExtendedTextMessage::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.title)
}
inline std::string* Message_ExtendedTextMessage::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.title)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  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 Message_ExtendedTextMessage::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _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:proto.Message.ExtendedTextMessage.title)
}

// optional fixed32 textArgb = 7;
inline bool Message_ExtendedTextMessage::_internal_has_textargb() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_textargb() const {
  return _internal_has_textargb();
}
inline void Message_ExtendedTextMessage::clear_textargb() {
  _impl_.textargb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t Message_ExtendedTextMessage::_internal_textargb() const {
  return _impl_.textargb_;
}
inline uint32_t Message_ExtendedTextMessage::textargb() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.textArgb)
  return _internal_textargb();
}
inline void Message_ExtendedTextMessage::_internal_set_textargb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.textargb_ = value;
}
inline void Message_ExtendedTextMessage::set_textargb(uint32_t value) {
  _internal_set_textargb(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.textArgb)
}

// optional fixed32 backgroundArgb = 8;
inline bool Message_ExtendedTextMessage::_internal_has_backgroundargb() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_backgroundargb() const {
  return _internal_has_backgroundargb();
}
inline void Message_ExtendedTextMessage::clear_backgroundargb() {
  _impl_.backgroundargb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t Message_ExtendedTextMessage::_internal_backgroundargb() const {
  return _impl_.backgroundargb_;
}
inline uint32_t Message_ExtendedTextMessage::backgroundargb() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.backgroundArgb)
  return _internal_backgroundargb();
}
inline void Message_ExtendedTextMessage::_internal_set_backgroundargb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.backgroundargb_ = value;
}
inline void Message_ExtendedTextMessage::set_backgroundargb(uint32_t value) {
  _internal_set_backgroundargb(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.backgroundArgb)
}

// optional .proto.Message.ExtendedTextMessage.FontType font = 9;
inline bool Message_ExtendedTextMessage::_internal_has_font() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_font() const {
  return _internal_has_font();
}
inline void Message_ExtendedTextMessage::clear_font() {
  _impl_.font_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::_internal_font() const {
  return static_cast< ::proto::Message_ExtendedTextMessage_FontType >(_impl_.font_);
}
inline ::proto::Message_ExtendedTextMessage_FontType Message_ExtendedTextMessage::font() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.font)
  return _internal_font();
}
inline void Message_ExtendedTextMessage::_internal_set_font(::proto::Message_ExtendedTextMessage_FontType value) {
  assert(::proto::Message_ExtendedTextMessage_FontType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.font_ = value;
}
inline void Message_ExtendedTextMessage::set_font(::proto::Message_ExtendedTextMessage_FontType value) {
  _internal_set_font(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.font)
}

// optional .proto.Message.ExtendedTextMessage.PreviewType previewType = 10;
inline bool Message_ExtendedTextMessage::_internal_has_previewtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_previewtype() const {
  return _internal_has_previewtype();
}
inline void Message_ExtendedTextMessage::clear_previewtype() {
  _impl_.previewtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::_internal_previewtype() const {
  return static_cast< ::proto::Message_ExtendedTextMessage_PreviewType >(_impl_.previewtype_);
}
inline ::proto::Message_ExtendedTextMessage_PreviewType Message_ExtendedTextMessage::previewtype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.previewType)
  return _internal_previewtype();
}
inline void Message_ExtendedTextMessage::_internal_set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) {
  assert(::proto::Message_ExtendedTextMessage_PreviewType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.previewtype_ = value;
}
inline void Message_ExtendedTextMessage::set_previewtype(::proto::Message_ExtendedTextMessage_PreviewType value) {
  _internal_set_previewtype(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.previewType)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_ExtendedTextMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_ExtendedTextMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_ExtendedTextMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.jpegThumbnail)
}
inline std::string* Message_ExtendedTextMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_ExtendedTextMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ExtendedTextMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ExtendedTextMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::ContextInfo& Message_ExtendedTextMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ExtendedTextMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ExtendedTextMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ExtendedTextMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ExtendedTextMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ExtendedTextMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ExtendedTextMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ExtendedTextMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.contextInfo)
  return _msg;
}
inline void Message_ExtendedTextMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.contextInfo)
}

// optional bool doNotPlayInline = 18;
inline bool Message_ExtendedTextMessage::_internal_has_donotplayinline() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_donotplayinline() const {
  return _internal_has_donotplayinline();
}
inline void Message_ExtendedTextMessage::clear_donotplayinline() {
  _impl_.donotplayinline_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool Message_ExtendedTextMessage::_internal_donotplayinline() const {
  return _impl_.donotplayinline_;
}
inline bool Message_ExtendedTextMessage::donotplayinline() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.doNotPlayInline)
  return _internal_donotplayinline();
}
inline void Message_ExtendedTextMessage::_internal_set_donotplayinline(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.donotplayinline_ = value;
}
inline void Message_ExtendedTextMessage::set_donotplayinline(bool value) {
  _internal_set_donotplayinline(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.doNotPlayInline)
}

// optional string thumbnailDirectPath = 19;
inline bool Message_ExtendedTextMessage::_internal_has_thumbnaildirectpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_thumbnaildirectpath() const {
  return _internal_has_thumbnaildirectpath();
}
inline void Message_ExtendedTextMessage::clear_thumbnaildirectpath() {
  _impl_.thumbnaildirectpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_ExtendedTextMessage::thumbnaildirectpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
  return _internal_thumbnaildirectpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
}
inline std::string* Message_ExtendedTextMessage::mutable_thumbnaildirectpath() {
  std::string* _s = _internal_mutable_thumbnaildirectpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_thumbnaildirectpath() const {
  return _impl_.thumbnaildirectpath_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnaildirectpath() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_thumbnaildirectpath() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
  if (!_internal_has_thumbnaildirectpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.thumbnaildirectpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
  if (thumbnaildirectpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailDirectPath)
}

// optional bytes thumbnailSha256 = 20;
inline bool Message_ExtendedTextMessage::_internal_has_thumbnailsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_thumbnailsha256() const {
  return _internal_has_thumbnailsha256();
}
inline void Message_ExtendedTextMessage::clear_thumbnailsha256() {
  _impl_.thumbnailsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_ExtendedTextMessage::thumbnailsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailSha256)
  return _internal_thumbnailsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailSha256)
}
inline std::string* Message_ExtendedTextMessage::mutable_thumbnailsha256() {
  std::string* _s = _internal_mutable_thumbnailsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailSha256)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailsha256() const {
  return _impl_.thumbnailsha256_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_thumbnailsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailsha256() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_thumbnailsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailSha256)
  if (!_internal_has_thumbnailsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.thumbnailsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
  if (thumbnailsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailSha256)
}

// optional bytes thumbnailEncSha256 = 21;
inline bool Message_ExtendedTextMessage::_internal_has_thumbnailencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_thumbnailencsha256() const {
  return _internal_has_thumbnailencsha256();
}
inline void Message_ExtendedTextMessage::clear_thumbnailencsha256() {
  _impl_.thumbnailencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Message_ExtendedTextMessage::thumbnailencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
  return _internal_thumbnailencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
}
inline std::string* Message_ExtendedTextMessage::mutable_thumbnailencsha256() {
  std::string* _s = _internal_mutable_thumbnailencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_thumbnailencsha256() const {
  return _impl_.thumbnailencsha256_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_thumbnailencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_thumbnailencsha256() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_thumbnailencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
  if (!_internal_has_thumbnailencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.thumbnailencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
  if (thumbnailencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.thumbnailEncSha256)
}

// optional bytes mediaKey = 22;
inline bool Message_ExtendedTextMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_ExtendedTextMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Message_ExtendedTextMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKey)
}
inline std::string* Message_ExtendedTextMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.mediaKey)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.mediaKey)
}

// optional int64 mediaKeyTimestamp = 23;
inline bool Message_ExtendedTextMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_ExtendedTextMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline int64_t Message_ExtendedTextMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_ExtendedTextMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_ExtendedTextMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_ExtendedTextMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.mediaKeyTimestamp)
}

// optional uint32 thumbnailHeight = 24;
inline bool Message_ExtendedTextMessage::_internal_has_thumbnailheight() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_thumbnailheight() const {
  return _internal_has_thumbnailheight();
}
inline void Message_ExtendedTextMessage::clear_thumbnailheight() {
  _impl_.thumbnailheight_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailheight() const {
  return _impl_.thumbnailheight_;
}
inline uint32_t Message_ExtendedTextMessage::thumbnailheight() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailHeight)
  return _internal_thumbnailheight();
}
inline void Message_ExtendedTextMessage::_internal_set_thumbnailheight(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.thumbnailheight_ = value;
}
inline void Message_ExtendedTextMessage::set_thumbnailheight(uint32_t value) {
  _internal_set_thumbnailheight(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailHeight)
}

// optional uint32 thumbnailWidth = 25;
inline bool Message_ExtendedTextMessage::_internal_has_thumbnailwidth() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_thumbnailwidth() const {
  return _internal_has_thumbnailwidth();
}
inline void Message_ExtendedTextMessage::clear_thumbnailwidth() {
  _impl_.thumbnailwidth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline uint32_t Message_ExtendedTextMessage::_internal_thumbnailwidth() const {
  return _impl_.thumbnailwidth_;
}
inline uint32_t Message_ExtendedTextMessage::thumbnailwidth() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.thumbnailWidth)
  return _internal_thumbnailwidth();
}
inline void Message_ExtendedTextMessage::_internal_set_thumbnailwidth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.thumbnailwidth_ = value;
}
inline void Message_ExtendedTextMessage::set_thumbnailwidth(uint32_t value) {
  _internal_set_thumbnailwidth(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.thumbnailWidth)
}

// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupType = 26;
inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptype() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_invitelinkgrouptype() const {
  return _internal_has_invitelinkgrouptype();
}
inline void Message_ExtendedTextMessage::clear_invitelinkgrouptype() {
  _impl_.invitelinkgrouptype_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptype() const {
  return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptype_);
}
inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupType)
  return _internal_invitelinkgrouptype();
}
inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
  assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.invitelinkgrouptype_ = value;
}
inline void Message_ExtendedTextMessage::set_invitelinkgrouptype(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
  _internal_set_invitelinkgrouptype(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupType)
}

// optional string inviteLinkParentGroupSubjectV2 = 27;
inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupsubjectv2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupsubjectv2() const {
  return _internal_has_invitelinkparentgroupsubjectv2();
}
inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupsubjectv2() {
  _impl_.invitelinkparentgroupsubjectv2_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupsubjectv2() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
  return _internal_invitelinkparentgroupsubjectv2();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_invitelinkparentgroupsubjectv2(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.invitelinkparentgroupsubjectv2_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
}
inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupsubjectv2() {
  std::string* _s = _internal_mutable_invitelinkparentgroupsubjectv2();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupsubjectv2() const {
  return _impl_.invitelinkparentgroupsubjectv2_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupsubjectv2(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.invitelinkparentgroupsubjectv2_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupsubjectv2() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.invitelinkparentgroupsubjectv2_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupsubjectv2() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
  if (!_internal_has_invitelinkparentgroupsubjectv2()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.invitelinkparentgroupsubjectv2_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) {
    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupsubjectv2(std::string* invitelinkparentgroupsubjectv2) {
  if (invitelinkparentgroupsubjectv2 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.invitelinkparentgroupsubjectv2_.SetAllocated(invitelinkparentgroupsubjectv2, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitelinkparentgroupsubjectv2_.IsDefault()) {
    _impl_.invitelinkparentgroupsubjectv2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupSubjectV2)
}

// optional bytes inviteLinkParentGroupThumbnailV2 = 28;
inline bool Message_ExtendedTextMessage::_internal_has_invitelinkparentgroupthumbnailv2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_invitelinkparentgroupthumbnailv2() const {
  return _internal_has_invitelinkparentgroupthumbnailv2();
}
inline void Message_ExtendedTextMessage::clear_invitelinkparentgroupthumbnailv2() {
  _impl_.invitelinkparentgroupthumbnailv2_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Message_ExtendedTextMessage::invitelinkparentgroupthumbnailv2() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
  return _internal_invitelinkparentgroupthumbnailv2();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ExtendedTextMessage::set_invitelinkparentgroupthumbnailv2(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.invitelinkparentgroupthumbnailv2_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
}
inline std::string* Message_ExtendedTextMessage::mutable_invitelinkparentgroupthumbnailv2() {
  std::string* _s = _internal_mutable_invitelinkparentgroupthumbnailv2();
  // @@protoc_insertion_point(field_mutable:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
  return _s;
}
inline const std::string& Message_ExtendedTextMessage::_internal_invitelinkparentgroupthumbnailv2() const {
  return _impl_.invitelinkparentgroupthumbnailv2_.Get();
}
inline void Message_ExtendedTextMessage::_internal_set_invitelinkparentgroupthumbnailv2(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.invitelinkparentgroupthumbnailv2_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::_internal_mutable_invitelinkparentgroupthumbnailv2() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.invitelinkparentgroupthumbnailv2_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ExtendedTextMessage::release_invitelinkparentgroupthumbnailv2() {
  // @@protoc_insertion_point(field_release:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
  if (!_internal_has_invitelinkparentgroupthumbnailv2()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.invitelinkparentgroupthumbnailv2_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) {
    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ExtendedTextMessage::set_allocated_invitelinkparentgroupthumbnailv2(std::string* invitelinkparentgroupthumbnailv2) {
  if (invitelinkparentgroupthumbnailv2 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.invitelinkparentgroupthumbnailv2_.SetAllocated(invitelinkparentgroupthumbnailv2, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitelinkparentgroupthumbnailv2_.IsDefault()) {
    _impl_.invitelinkparentgroupthumbnailv2_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ExtendedTextMessage.inviteLinkParentGroupThumbnailV2)
}

// optional .proto.Message.ExtendedTextMessage.InviteLinkGroupType inviteLinkGroupTypeV2 = 29;
inline bool Message_ExtendedTextMessage::_internal_has_invitelinkgrouptypev2() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool Message_ExtendedTextMessage::has_invitelinkgrouptypev2() const {
  return _internal_has_invitelinkgrouptypev2();
}
inline void Message_ExtendedTextMessage::clear_invitelinkgrouptypev2() {
  _impl_.invitelinkgrouptypev2_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::_internal_invitelinkgrouptypev2() const {
  return static_cast< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType >(_impl_.invitelinkgrouptypev2_);
}
inline ::proto::Message_ExtendedTextMessage_InviteLinkGroupType Message_ExtendedTextMessage::invitelinkgrouptypev2() const {
  // @@protoc_insertion_point(field_get:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2)
  return _internal_invitelinkgrouptypev2();
}
inline void Message_ExtendedTextMessage::_internal_set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
  assert(::proto::Message_ExtendedTextMessage_InviteLinkGroupType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.invitelinkgrouptypev2_ = value;
}
inline void Message_ExtendedTextMessage::set_invitelinkgrouptypev2(::proto::Message_ExtendedTextMessage_InviteLinkGroupType value) {
  _internal_set_invitelinkgrouptypev2(value);
  // @@protoc_insertion_point(field_set:proto.Message.ExtendedTextMessage.inviteLinkGroupTypeV2)
}

// -------------------------------------------------------------------

// Message_FutureProofMessage

// optional .proto.Message message = 1;
inline bool Message_FutureProofMessage::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
  return value;
}
inline bool Message_FutureProofMessage::has_message() const {
  return _internal_has_message();
}
inline void Message_FutureProofMessage::clear_message() {
  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message& Message_FutureProofMessage::_internal_message() const {
  const ::proto::Message* p = _impl_.message_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& Message_FutureProofMessage::message() const {
  // @@protoc_insertion_point(field_get:proto.Message.FutureProofMessage.message)
  return _internal_message();
}
inline void Message_FutureProofMessage::unsafe_arena_set_allocated_message(
    ::proto::Message* message) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
  }
  _impl_.message_ = message;
  if (message) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.FutureProofMessage.message)
}
inline ::proto::Message* Message_FutureProofMessage::release_message() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = 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 ::proto::Message* Message_FutureProofMessage::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_release:proto.Message.FutureProofMessage.message)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = nullptr;
  return temp;
}
inline ::proto::Message* Message_FutureProofMessage::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.message_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.message_ = p;
  }
  return _impl_.message_;
}
inline ::proto::Message* Message_FutureProofMessage::mutable_message() {
  ::proto::Message* _msg = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.Message.FutureProofMessage.message)
  return _msg;
}
inline void Message_FutureProofMessage::set_allocated_message(::proto::Message* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.message_ = message;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.FutureProofMessage.message)
}

// -------------------------------------------------------------------

// Message_GroupInviteMessage

// optional string groupJid = 1;
inline bool Message_GroupInviteMessage::_internal_has_groupjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_groupjid() const {
  return _internal_has_groupjid();
}
inline void Message_GroupInviteMessage::clear_groupjid() {
  _impl_.groupjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_GroupInviteMessage::groupjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupJid)
  return _internal_groupjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_GroupInviteMessage::set_groupjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.groupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupJid)
}
inline std::string* Message_GroupInviteMessage::mutable_groupjid() {
  std::string* _s = _internal_mutable_groupjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupJid)
  return _s;
}
inline const std::string& Message_GroupInviteMessage::_internal_groupjid() const {
  return _impl_.groupjid_.Get();
}
inline void Message_GroupInviteMessage::_internal_set_groupjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::_internal_mutable_groupjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.groupjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::release_groupjid() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupJid)
  if (!_internal_has_groupjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.groupjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupjid_.IsDefault()) {
    _impl_.groupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_GroupInviteMessage::set_allocated_groupjid(std::string* groupjid) {
  if (groupjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupjid_.IsDefault()) {
    _impl_.groupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupJid)
}

// optional string inviteCode = 2;
inline bool Message_GroupInviteMessage::_internal_has_invitecode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_invitecode() const {
  return _internal_has_invitecode();
}
inline void Message_GroupInviteMessage::clear_invitecode() {
  _impl_.invitecode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_GroupInviteMessage::invitecode() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteCode)
  return _internal_invitecode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_GroupInviteMessage::set_invitecode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.invitecode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteCode)
}
inline std::string* Message_GroupInviteMessage::mutable_invitecode() {
  std::string* _s = _internal_mutable_invitecode();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.inviteCode)
  return _s;
}
inline const std::string& Message_GroupInviteMessage::_internal_invitecode() const {
  return _impl_.invitecode_.Get();
}
inline void Message_GroupInviteMessage::_internal_set_invitecode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.invitecode_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::_internal_mutable_invitecode() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.invitecode_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::release_invitecode() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.inviteCode)
  if (!_internal_has_invitecode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.invitecode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitecode_.IsDefault()) {
    _impl_.invitecode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_GroupInviteMessage::set_allocated_invitecode(std::string* invitecode) {
  if (invitecode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.invitecode_.SetAllocated(invitecode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.invitecode_.IsDefault()) {
    _impl_.invitecode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.inviteCode)
}

// optional int64 inviteExpiration = 3;
inline bool Message_GroupInviteMessage::_internal_has_inviteexpiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_inviteexpiration() const {
  return _internal_has_inviteexpiration();
}
inline void Message_GroupInviteMessage::clear_inviteexpiration() {
  _impl_.inviteexpiration_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int64_t Message_GroupInviteMessage::_internal_inviteexpiration() const {
  return _impl_.inviteexpiration_;
}
inline int64_t Message_GroupInviteMessage::inviteexpiration() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.inviteExpiration)
  return _internal_inviteexpiration();
}
inline void Message_GroupInviteMessage::_internal_set_inviteexpiration(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.inviteexpiration_ = value;
}
inline void Message_GroupInviteMessage::set_inviteexpiration(int64_t value) {
  _internal_set_inviteexpiration(value);
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.inviteExpiration)
}

// optional string groupName = 4;
inline bool Message_GroupInviteMessage::_internal_has_groupname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_groupname() const {
  return _internal_has_groupname();
}
inline void Message_GroupInviteMessage::clear_groupname() {
  _impl_.groupname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_GroupInviteMessage::groupname() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupName)
  return _internal_groupname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_GroupInviteMessage::set_groupname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.groupname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupName)
}
inline std::string* Message_GroupInviteMessage::mutable_groupname() {
  std::string* _s = _internal_mutable_groupname();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.groupName)
  return _s;
}
inline const std::string& Message_GroupInviteMessage::_internal_groupname() const {
  return _impl_.groupname_.Get();
}
inline void Message_GroupInviteMessage::_internal_set_groupname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.groupname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::_internal_mutable_groupname() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.groupname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::release_groupname() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.groupName)
  if (!_internal_has_groupname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.groupname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupname_.IsDefault()) {
    _impl_.groupname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_GroupInviteMessage::set_allocated_groupname(std::string* groupname) {
  if (groupname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.groupname_.SetAllocated(groupname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupname_.IsDefault()) {
    _impl_.groupname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.groupName)
}

// optional bytes jpegThumbnail = 5;
inline bool Message_GroupInviteMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_GroupInviteMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_GroupInviteMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_GroupInviteMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.jpegThumbnail)
}
inline std::string* Message_GroupInviteMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_GroupInviteMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_GroupInviteMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_GroupInviteMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.jpegThumbnail)
}

// optional string caption = 6;
inline bool Message_GroupInviteMessage::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_caption() const {
  return _internal_has_caption();
}
inline void Message_GroupInviteMessage::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_GroupInviteMessage::caption() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_GroupInviteMessage::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.caption)
}
inline std::string* Message_GroupInviteMessage::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.caption)
  return _s;
}
inline const std::string& Message_GroupInviteMessage::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void Message_GroupInviteMessage::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_GroupInviteMessage::release_caption() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  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 Message_GroupInviteMessage::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _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:proto.Message.GroupInviteMessage.caption)
}

// optional .proto.ContextInfo contextInfo = 7;
inline bool Message_GroupInviteMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_GroupInviteMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_GroupInviteMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ContextInfo& Message_GroupInviteMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_GroupInviteMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_GroupInviteMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.GroupInviteMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_GroupInviteMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_GroupInviteMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.GroupInviteMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_GroupInviteMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_GroupInviteMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.GroupInviteMessage.contextInfo)
  return _msg;
}
inline void Message_GroupInviteMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.GroupInviteMessage.contextInfo)
}

// optional .proto.Message.GroupInviteMessage.GroupType groupType = 8;
inline bool Message_GroupInviteMessage::_internal_has_grouptype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_GroupInviteMessage::has_grouptype() const {
  return _internal_has_grouptype();
}
inline void Message_GroupInviteMessage::clear_grouptype() {
  _impl_.grouptype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::_internal_grouptype() const {
  return static_cast< ::proto::Message_GroupInviteMessage_GroupType >(_impl_.grouptype_);
}
inline ::proto::Message_GroupInviteMessage_GroupType Message_GroupInviteMessage::grouptype() const {
  // @@protoc_insertion_point(field_get:proto.Message.GroupInviteMessage.groupType)
  return _internal_grouptype();
}
inline void Message_GroupInviteMessage::_internal_set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) {
  assert(::proto::Message_GroupInviteMessage_GroupType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.grouptype_ = value;
}
inline void Message_GroupInviteMessage::set_grouptype(::proto::Message_GroupInviteMessage_GroupType value) {
  _internal_set_grouptype(value);
  // @@protoc_insertion_point(field_set:proto.Message.GroupInviteMessage.groupType)
}

// -------------------------------------------------------------------

// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency

// optional string currencyCode = 1;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_currencycode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_currencycode() const {
  return _internal_has_currencycode();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_currencycode() {
  _impl_.currencycode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::currencycode() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
  return _internal_currencycode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_currencycode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::mutable_currencycode() {
  std::string* _s = _internal_mutable_currencycode();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_currencycode() const {
  return _impl_.currencycode_.Get();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_currencycode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.currencycode_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_mutable_currencycode() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::release_currencycode() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
  if (!_internal_has_currencycode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.currencycode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_allocated_currencycode(std::string* currencycode) {
  if (currencycode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.currencyCode)
}

// optional int64 amount1000 = 2;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_has_amount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::has_amount1000() const {
  return _internal_has_amount1000();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::clear_amount1000() {
  _impl_.amount1000_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_amount1000() const {
  return _impl_.amount1000_;
}
inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::amount1000() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000)
  return _internal_amount1000();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::_internal_set_amount1000(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.amount1000_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency::set_amount1000(int64_t value) {
  _internal_set_amount1000(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency.amount1000)
}

// -------------------------------------------------------------------

// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent

// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.DayOfWeekType dayOfWeek = 1;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofweek() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofweek() const {
  return _internal_has_dayofweek();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofweek() {
  _impl_.dayofweek_ = 1;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofweek() const {
  return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType >(_impl_.dayofweek_);
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofweek() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek)
  return _internal_dayofweek();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) {
  assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.dayofweek_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofweek(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType value) {
  _internal_set_dayofweek(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfWeek)
}

// optional uint32 year = 2;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_year() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_year() const {
  return _internal_has_year();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_year() {
  _impl_.year_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_year() const {
  return _impl_.year_;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::year() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year)
  return _internal_year();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_year(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.year_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_year(uint32_t value) {
  _internal_set_year(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.year)
}

// optional uint32 month = 3;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_month() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_month() const {
  return _internal_has_month();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_month() {
  _impl_.month_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_month() const {
  return _impl_.month_;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::month() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month)
  return _internal_month();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_month(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.month_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_month(uint32_t value) {
  _internal_set_month(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.month)
}

// optional uint32 dayOfMonth = 4;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_dayofmonth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_dayofmonth() const {
  return _internal_has_dayofmonth();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_dayofmonth() {
  _impl_.dayofmonth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_dayofmonth() const {
  return _impl_.dayofmonth_;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::dayofmonth() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth)
  return _internal_dayofmonth();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_dayofmonth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.dayofmonth_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_dayofmonth(uint32_t value) {
  _internal_set_dayofmonth(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.dayOfMonth)
}

// optional uint32 hour = 5;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_hour() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_hour() const {
  return _internal_has_hour();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_hour() {
  _impl_.hour_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_hour() const {
  return _impl_.hour_;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::hour() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour)
  return _internal_hour();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_hour(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.hour_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_hour(uint32_t value) {
  _internal_set_hour(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.hour)
}

// optional uint32 minute = 6;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_minute() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_minute() const {
  return _internal_has_minute();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_minute() {
  _impl_.minute_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_minute() const {
  return _impl_.minute_;
}
inline uint32_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::minute() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute)
  return _internal_minute();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_minute(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.minute_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_minute(uint32_t value) {
  _internal_set_minute(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.minute)
}

// optional .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.CalendarType calendar = 7;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_has_calendar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::has_calendar() const {
  return _internal_has_calendar();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::clear_calendar() {
  _impl_.calendar_ = 1;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_calendar() const {
  return static_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType >(_impl_.calendar_);
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::calendar() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar)
  return _internal_calendar();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::_internal_set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) {
  assert(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.calendar_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent::set_calendar(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType value) {
  _internal_set_calendar(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent.calendar)
}

// -------------------------------------------------------------------

// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch

// optional int64 timestamp = 1;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp)
  return _internal_timestamp();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch.timestamp)
}

// -------------------------------------------------------------------

// Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime

// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeComponent component = 1;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_component() const {
  return datetimeOneof_case() == kComponent;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_component() const {
  return _internal_has_component();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_component() {
  _impl_._oneof_case_[0] = kComponent;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_component() {
  if (_internal_has_component()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.datetimeOneof_.component_;
    }
    clear_has_datetimeOneof();
  }
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_component() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
  if (_internal_has_component()) {
    clear_has_datetimeOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.datetimeOneof_.component_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_component() const {
  return _internal_has_component()
      ? *_impl_.datetimeOneof_.component_
      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::component() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
  return _internal_component();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_component() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
  if (_internal_has_component()) {
    clear_has_datetimeOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* temp = _impl_.datetimeOneof_.component_;
    _impl_.datetimeOneof_.component_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_component(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* component) {
  clear_datetimeOneof();
  if (component) {
    set_has_component();
    _impl_.datetimeOneof_.component_ = component;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_component() {
  if (!_internal_has_component()) {
    clear_datetimeOneof();
    set_has_component();
    _impl_.datetimeOneof_.component_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent >(GetArenaForAllocation());
  }
  return _impl_.datetimeOneof_.component_;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_component() {
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent* _msg = _internal_mutable_component();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.component)
  return _msg;
}

// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.HSMDateTimeUnixEpoch unixEpoch = 2;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_has_unixepoch() const {
  return datetimeOneof_case() == kUnixEpoch;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_unixepoch() const {
  return _internal_has_unixepoch();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::set_has_unixepoch() {
  _impl_._oneof_case_[0] = kUnixEpoch;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_unixepoch() {
  if (_internal_has_unixepoch()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.datetimeOneof_.unixepoch_;
    }
    clear_has_datetimeOneof();
  }
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::release_unixepoch() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
  if (_internal_has_unixepoch()) {
    clear_has_datetimeOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.datetimeOneof_.unixepoch_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_unixepoch() const {
  return _internal_has_unixepoch()
      ? *_impl_.datetimeOneof_.unixepoch_
      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch& Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unixepoch() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
  return _internal_unixepoch();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_release_unixepoch() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
  if (_internal_has_unixepoch()) {
    clear_has_datetimeOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* temp = _impl_.datetimeOneof_.unixepoch_;
    _impl_.datetimeOneof_.unixepoch_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::unsafe_arena_set_allocated_unixepoch(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* unixepoch) {
  clear_datetimeOneof();
  if (unixepoch) {
    set_has_unixepoch();
    _impl_.datetimeOneof_.unixepoch_ = unixepoch;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::_internal_mutable_unixepoch() {
  if (!_internal_has_unixepoch()) {
    clear_datetimeOneof();
    set_has_unixepoch();
    _impl_.datetimeOneof_.unixepoch_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch >(GetArenaForAllocation());
  }
  return _impl_.datetimeOneof_.unixepoch_;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::mutable_unixepoch() {
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeUnixEpoch* _msg = _internal_mutable_unixepoch();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime.unixEpoch)
  return _msg;
}

inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::has_datetimeOneof() const {
  return datetimeOneof_case() != DATETIMEONEOF_NOT_SET;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::clear_has_datetimeOneof() {
  _impl_._oneof_case_[0] = DATETIMEONEOF_NOT_SET;
}
inline Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::datetimeOneof_case() const {
  return Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime::DatetimeOneofCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_HighlyStructuredMessage_HSMLocalizableParameter

// optional string default = 1;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_default_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_default_() const {
  return _internal_has_default_();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_default_() {
  _impl_.default__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::default_() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
  return _internal_default_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_default_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.default__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_default_() {
  std::string* _s = _internal_mutable_default_();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_default_() const {
  return _impl_.default__.Get();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_set_default_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.default__.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_default_() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.default__.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_default_() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
  if (!_internal_has_default_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.default__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.default__.IsDefault()) {
    _impl_.default__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_allocated_default_(std::string* default_) {
  if (default_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.default__.SetAllocated(default_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.default__.IsDefault()) {
    _impl_.default__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.default)
}

// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMCurrency currency = 2;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_currency() const {
  return paramOneof_case() == kCurrency;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_currency() const {
  return _internal_has_currency();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_currency() {
  _impl_._oneof_case_[0] = kCurrency;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_currency() {
  if (_internal_has_currency()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.paramOneof_.currency_;
    }
    clear_has_paramOneof();
  }
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_currency() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
  if (_internal_has_currency()) {
    clear_has_paramOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.paramOneof_.currency_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_currency() const {
  return _internal_has_currency()
      ? *_impl_.paramOneof_.currency_
      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency& Message_HighlyStructuredMessage_HSMLocalizableParameter::currency() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
  return _internal_currency();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_currency() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
  if (_internal_has_currency()) {
    clear_has_paramOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* temp = _impl_.paramOneof_.currency_;
    _impl_.paramOneof_.currency_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_currency(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* currency) {
  clear_paramOneof();
  if (currency) {
    set_has_currency();
    _impl_.paramOneof_.currency_ = currency;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_currency() {
  if (!_internal_has_currency()) {
    clear_paramOneof();
    set_has_currency();
    _impl_.paramOneof_.currency_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency >(GetArenaForAllocation());
  }
  return _impl_.paramOneof_.currency_;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_currency() {
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMCurrency* _msg = _internal_mutable_currency();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.currency)
  return _msg;
}

// .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.HSMDateTime dateTime = 3;
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_has_datetime() const {
  return paramOneof_case() == kDateTime;
}
inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_datetime() const {
  return _internal_has_datetime();
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::set_has_datetime() {
  _impl_._oneof_case_[0] = kDateTime;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_datetime() {
  if (_internal_has_datetime()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.paramOneof_.datetime_;
    }
    clear_has_paramOneof();
  }
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::release_datetime() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
  if (_internal_has_datetime()) {
    clear_has_paramOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.paramOneof_.datetime_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_datetime() const {
  return _internal_has_datetime()
      ? *_impl_.paramOneof_.datetime_
      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime&>(::proto::_Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime& Message_HighlyStructuredMessage_HSMLocalizableParameter::datetime() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
  return _internal_datetime();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_release_datetime() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
  if (_internal_has_datetime()) {
    clear_has_paramOneof();
    ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* temp = _impl_.paramOneof_.datetime_;
    _impl_.paramOneof_.datetime_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::unsafe_arena_set_allocated_datetime(::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* datetime) {
  clear_paramOneof();
  if (datetime) {
    set_has_datetime();
    _impl_.paramOneof_.datetime_ = datetime;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::_internal_mutable_datetime() {
  if (!_internal_has_datetime()) {
    clear_paramOneof();
    set_has_datetime();
    _impl_.paramOneof_.datetime_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime >(GetArenaForAllocation());
  }
  return _impl_.paramOneof_.datetime_;
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* Message_HighlyStructuredMessage_HSMLocalizableParameter::mutable_datetime() {
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime* _msg = _internal_mutable_datetime();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.HSMLocalizableParameter.dateTime)
  return _msg;
}

inline bool Message_HighlyStructuredMessage_HSMLocalizableParameter::has_paramOneof() const {
  return paramOneof_case() != PARAMONEOF_NOT_SET;
}
inline void Message_HighlyStructuredMessage_HSMLocalizableParameter::clear_has_paramOneof() {
  _impl_._oneof_case_[0] = PARAMONEOF_NOT_SET;
}
inline Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase Message_HighlyStructuredMessage_HSMLocalizableParameter::paramOneof_case() const {
  return Message_HighlyStructuredMessage_HSMLocalizableParameter::ParamOneofCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_HighlyStructuredMessage

// optional string namespace = 1;
inline bool Message_HighlyStructuredMessage::_internal_has_namespace_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_namespace_() const {
  return _internal_has_namespace_();
}
inline void Message_HighlyStructuredMessage::clear_namespace_() {
  _impl_.namespace__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_HighlyStructuredMessage::namespace_() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.namespace)
  return _internal_namespace_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_namespace_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.namespace)
}
inline std::string* Message_HighlyStructuredMessage::mutable_namespace_() {
  std::string* _s = _internal_mutable_namespace_();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.namespace)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_namespace_() const {
  return _impl_.namespace__.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_namespace_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.namespace__.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_namespace_() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.namespace__.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_namespace_() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.namespace)
  if (!_internal_has_namespace_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.namespace__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.namespace__.IsDefault()) {
    _impl_.namespace__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_namespace_(std::string* namespace_) {
  if (namespace_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.namespace__.IsDefault()) {
    _impl_.namespace__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.namespace)
}

// optional string elementName = 2;
inline bool Message_HighlyStructuredMessage::_internal_has_elementname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_elementname() const {
  return _internal_has_elementname();
}
inline void Message_HighlyStructuredMessage::clear_elementname() {
  _impl_.elementname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_HighlyStructuredMessage::elementname() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.elementName)
  return _internal_elementname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_elementname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.elementname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.elementName)
}
inline std::string* Message_HighlyStructuredMessage::mutable_elementname() {
  std::string* _s = _internal_mutable_elementname();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.elementName)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_elementname() const {
  return _impl_.elementname_.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_elementname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.elementname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_elementname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.elementname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_elementname() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.elementName)
  if (!_internal_has_elementname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.elementname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.elementname_.IsDefault()) {
    _impl_.elementname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_elementname(std::string* elementname) {
  if (elementname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.elementname_.SetAllocated(elementname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.elementname_.IsDefault()) {
    _impl_.elementname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.elementName)
}

// repeated string params = 3;
inline int Message_HighlyStructuredMessage::_internal_params_size() const {
  return _impl_.params_.size();
}
inline int Message_HighlyStructuredMessage::params_size() const {
  return _internal_params_size();
}
inline void Message_HighlyStructuredMessage::clear_params() {
  _impl_.params_.Clear();
}
inline std::string* Message_HighlyStructuredMessage::add_params() {
  std::string* _s = _internal_add_params();
  // @@protoc_insertion_point(field_add_mutable:proto.Message.HighlyStructuredMessage.params)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_params(int index) const {
  return _impl_.params_.Get(index);
}
inline const std::string& Message_HighlyStructuredMessage::params(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.params)
  return _internal_params(index);
}
inline std::string* Message_HighlyStructuredMessage::mutable_params(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.params)
  return _impl_.params_.Mutable(index);
}
inline void Message_HighlyStructuredMessage::set_params(int index, const std::string& value) {
  _impl_.params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::set_params(int index, std::string&& value) {
  _impl_.params_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::set_params(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.params_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::set_params(int index, const char* value, size_t size) {
  _impl_.params_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.Message.HighlyStructuredMessage.params)
}
inline std::string* Message_HighlyStructuredMessage::_internal_add_params() {
  return _impl_.params_.Add();
}
inline void Message_HighlyStructuredMessage::add_params(const std::string& value) {
  _impl_.params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::add_params(std::string&& value) {
  _impl_.params_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::add_params(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.params_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.Message.HighlyStructuredMessage.params)
}
inline void Message_HighlyStructuredMessage::add_params(const char* value, size_t size) {
  _impl_.params_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.Message.HighlyStructuredMessage.params)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Message_HighlyStructuredMessage::params() const {
  // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.params)
  return _impl_.params_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Message_HighlyStructuredMessage::mutable_params() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.params)
  return &_impl_.params_;
}

// optional string fallbackLg = 4;
inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_fallbacklg() const {
  return _internal_has_fallbacklg();
}
inline void Message_HighlyStructuredMessage::clear_fallbacklg() {
  _impl_.fallbacklg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_HighlyStructuredMessage::fallbacklg() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLg)
  return _internal_fallbacklg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_fallbacklg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fallbacklg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLg)
}
inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklg() {
  std::string* _s = _internal_mutable_fallbacklg();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLg)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklg() const {
  return _impl_.fallbacklg_.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_fallbacklg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fallbacklg_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklg() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fallbacklg_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_fallbacklg() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLg)
  if (!_internal_has_fallbacklg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fallbacklg_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fallbacklg_.IsDefault()) {
    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_fallbacklg(std::string* fallbacklg) {
  if (fallbacklg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fallbacklg_.SetAllocated(fallbacklg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fallbacklg_.IsDefault()) {
    _impl_.fallbacklg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLg)
}

// optional string fallbackLc = 5;
inline bool Message_HighlyStructuredMessage::_internal_has_fallbacklc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_fallbacklc() const {
  return _internal_has_fallbacklc();
}
inline void Message_HighlyStructuredMessage::clear_fallbacklc() {
  _impl_.fallbacklc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_HighlyStructuredMessage::fallbacklc() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.fallbackLc)
  return _internal_fallbacklc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_fallbacklc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.fallbacklc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.fallbackLc)
}
inline std::string* Message_HighlyStructuredMessage::mutable_fallbacklc() {
  std::string* _s = _internal_mutable_fallbacklc();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.fallbackLc)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_fallbacklc() const {
  return _impl_.fallbacklc_.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_fallbacklc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.fallbacklc_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_fallbacklc() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.fallbacklc_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_fallbacklc() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.fallbackLc)
  if (!_internal_has_fallbacklc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.fallbacklc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fallbacklc_.IsDefault()) {
    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_fallbacklc(std::string* fallbacklc) {
  if (fallbacklc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.fallbacklc_.SetAllocated(fallbacklc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fallbacklc_.IsDefault()) {
    _impl_.fallbacklc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.fallbackLc)
}

// repeated .proto.Message.HighlyStructuredMessage.HSMLocalizableParameter localizableParams = 6;
inline int Message_HighlyStructuredMessage::_internal_localizableparams_size() const {
  return _impl_.localizableparams_.size();
}
inline int Message_HighlyStructuredMessage::localizableparams_size() const {
  return _internal_localizableparams_size();
}
inline void Message_HighlyStructuredMessage::clear_localizableparams() {
  _impl_.localizableparams_.Clear();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::mutable_localizableparams(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.localizableParams)
  return _impl_.localizableparams_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >*
Message_HighlyStructuredMessage::mutable_localizableparams() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.HighlyStructuredMessage.localizableParams)
  return &_impl_.localizableparams_;
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::_internal_localizableparams(int index) const {
  return _impl_.localizableparams_.Get(index);
}
inline const ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter& Message_HighlyStructuredMessage::localizableparams(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.localizableParams)
  return _internal_localizableparams(index);
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::_internal_add_localizableparams() {
  return _impl_.localizableparams_.Add();
}
inline ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* Message_HighlyStructuredMessage::add_localizableparams() {
  ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter* _add = _internal_add_localizableparams();
  // @@protoc_insertion_point(field_add:proto.Message.HighlyStructuredMessage.localizableParams)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter >&
Message_HighlyStructuredMessage::localizableparams() const {
  // @@protoc_insertion_point(field_list:proto.Message.HighlyStructuredMessage.localizableParams)
  return _impl_.localizableparams_;
}

// optional string deterministicLg = 7;
inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_deterministiclg() const {
  return _internal_has_deterministiclg();
}
inline void Message_HighlyStructuredMessage::clear_deterministiclg() {
  _impl_.deterministiclg_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_HighlyStructuredMessage::deterministiclg() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLg)
  return _internal_deterministiclg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_deterministiclg(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.deterministiclg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLg)
}
inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclg() {
  std::string* _s = _internal_mutable_deterministiclg();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLg)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclg() const {
  return _impl_.deterministiclg_.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_deterministiclg(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.deterministiclg_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclg() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.deterministiclg_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_deterministiclg() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLg)
  if (!_internal_has_deterministiclg()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.deterministiclg_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deterministiclg_.IsDefault()) {
    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_deterministiclg(std::string* deterministiclg) {
  if (deterministiclg != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.deterministiclg_.SetAllocated(deterministiclg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deterministiclg_.IsDefault()) {
    _impl_.deterministiclg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLg)
}

// optional string deterministicLc = 8;
inline bool Message_HighlyStructuredMessage::_internal_has_deterministiclc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_HighlyStructuredMessage::has_deterministiclc() const {
  return _internal_has_deterministiclc();
}
inline void Message_HighlyStructuredMessage::clear_deterministiclc() {
  _impl_.deterministiclc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_HighlyStructuredMessage::deterministiclc() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.deterministicLc)
  return _internal_deterministiclc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HighlyStructuredMessage::set_deterministiclc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.deterministiclc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HighlyStructuredMessage.deterministicLc)
}
inline std::string* Message_HighlyStructuredMessage::mutable_deterministiclc() {
  std::string* _s = _internal_mutable_deterministiclc();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.deterministicLc)
  return _s;
}
inline const std::string& Message_HighlyStructuredMessage::_internal_deterministiclc() const {
  return _impl_.deterministiclc_.Get();
}
inline void Message_HighlyStructuredMessage::_internal_set_deterministiclc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.deterministiclc_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::_internal_mutable_deterministiclc() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.deterministiclc_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HighlyStructuredMessage::release_deterministiclc() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.deterministicLc)
  if (!_internal_has_deterministiclc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.deterministiclc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deterministiclc_.IsDefault()) {
    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HighlyStructuredMessage::set_allocated_deterministiclc(std::string* deterministiclc) {
  if (deterministiclc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.deterministiclc_.SetAllocated(deterministiclc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.deterministiclc_.IsDefault()) {
    _impl_.deterministiclc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.deterministicLc)
}

// optional .proto.Message.TemplateMessage hydratedHsm = 9;
inline bool Message_HighlyStructuredMessage::_internal_has_hydratedhsm() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hydratedhsm_ != nullptr);
  return value;
}
inline bool Message_HighlyStructuredMessage::has_hydratedhsm() const {
  return _internal_has_hydratedhsm();
}
inline void Message_HighlyStructuredMessage::clear_hydratedhsm() {
  if (_impl_.hydratedhsm_ != nullptr) _impl_.hydratedhsm_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::_internal_hydratedhsm() const {
  const ::proto::Message_TemplateMessage* p = _impl_.hydratedhsm_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage&>(
      ::proto::_Message_TemplateMessage_default_instance_);
}
inline const ::proto::Message_TemplateMessage& Message_HighlyStructuredMessage::hydratedhsm() const {
  // @@protoc_insertion_point(field_get:proto.Message.HighlyStructuredMessage.hydratedHsm)
  return _internal_hydratedhsm();
}
inline void Message_HighlyStructuredMessage::unsafe_arena_set_allocated_hydratedhsm(
    ::proto::Message_TemplateMessage* hydratedhsm) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedhsm_);
  }
  _impl_.hydratedhsm_ = hydratedhsm;
  if (hydratedhsm) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm)
}
inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::release_hydratedhsm() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_;
  _impl_.hydratedhsm_ = 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 ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::unsafe_arena_release_hydratedhsm() {
  // @@protoc_insertion_point(field_release:proto.Message.HighlyStructuredMessage.hydratedHsm)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::Message_TemplateMessage* temp = _impl_.hydratedhsm_;
  _impl_.hydratedhsm_ = nullptr;
  return temp;
}
inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::_internal_mutable_hydratedhsm() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.hydratedhsm_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation());
    _impl_.hydratedhsm_ = p;
  }
  return _impl_.hydratedhsm_;
}
inline ::proto::Message_TemplateMessage* Message_HighlyStructuredMessage::mutable_hydratedhsm() {
  ::proto::Message_TemplateMessage* _msg = _internal_mutable_hydratedhsm();
  // @@protoc_insertion_point(field_mutable:proto.Message.HighlyStructuredMessage.hydratedHsm)
  return _msg;
}
inline void Message_HighlyStructuredMessage::set_allocated_hydratedhsm(::proto::Message_TemplateMessage* hydratedhsm) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hydratedhsm_;
  }
  if (hydratedhsm) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedhsm);
    if (message_arena != submessage_arena) {
      hydratedhsm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hydratedhsm, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.hydratedhsm_ = hydratedhsm;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HighlyStructuredMessage.hydratedHsm)
}

// -------------------------------------------------------------------

// Message_HistorySyncNotification

// optional bytes fileSha256 = 1;
inline bool Message_HistorySyncNotification::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_HistorySyncNotification::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_HistorySyncNotification::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HistorySyncNotification::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileSha256)
}
inline std::string* Message_HistorySyncNotification::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileSha256)
  return _s;
}
inline const std::string& Message_HistorySyncNotification::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_HistorySyncNotification::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HistorySyncNotification::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileSha256)
}

// optional uint64 fileLength = 2;
inline bool Message_HistorySyncNotification::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_HistorySyncNotification::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t Message_HistorySyncNotification::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_HistorySyncNotification::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileLength)
  return _internal_filelength();
}
inline void Message_HistorySyncNotification::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.filelength_ = value;
}
inline void Message_HistorySyncNotification::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileLength)
}

// optional bytes mediaKey = 3;
inline bool Message_HistorySyncNotification::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_HistorySyncNotification::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_HistorySyncNotification::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HistorySyncNotification::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.mediaKey)
}
inline std::string* Message_HistorySyncNotification::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.mediaKey)
  return _s;
}
inline const std::string& Message_HistorySyncNotification::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_HistorySyncNotification::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HistorySyncNotification::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.mediaKey)
}

// optional bytes fileEncSha256 = 4;
inline bool Message_HistorySyncNotification::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_HistorySyncNotification::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_HistorySyncNotification::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HistorySyncNotification::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.fileEncSha256)
}
inline std::string* Message_HistorySyncNotification::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.fileEncSha256)
  return _s;
}
inline const std::string& Message_HistorySyncNotification::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_HistorySyncNotification::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HistorySyncNotification::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.fileEncSha256)
}

// optional string directPath = 5;
inline bool Message_HistorySyncNotification::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_HistorySyncNotification::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_HistorySyncNotification::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HistorySyncNotification::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.directPath)
}
inline std::string* Message_HistorySyncNotification::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.directPath)
  return _s;
}
inline const std::string& Message_HistorySyncNotification::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_HistorySyncNotification::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HistorySyncNotification::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.directPath)
}

// optional .proto.Message.HistorySyncNotification.HistorySyncType syncType = 6;
inline bool Message_HistorySyncNotification::_internal_has_synctype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_synctype() const {
  return _internal_has_synctype();
}
inline void Message_HistorySyncNotification::clear_synctype() {
  _impl_.synctype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::_internal_synctype() const {
  return static_cast< ::proto::Message_HistorySyncNotification_HistorySyncType >(_impl_.synctype_);
}
inline ::proto::Message_HistorySyncNotification_HistorySyncType Message_HistorySyncNotification::synctype() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.syncType)
  return _internal_synctype();
}
inline void Message_HistorySyncNotification::_internal_set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) {
  assert(::proto::Message_HistorySyncNotification_HistorySyncType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.synctype_ = value;
}
inline void Message_HistorySyncNotification::set_synctype(::proto::Message_HistorySyncNotification_HistorySyncType value) {
  _internal_set_synctype(value);
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.syncType)
}

// optional uint32 chunkOrder = 7;
inline bool Message_HistorySyncNotification::_internal_has_chunkorder() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_chunkorder() const {
  return _internal_has_chunkorder();
}
inline void Message_HistorySyncNotification::clear_chunkorder() {
  _impl_.chunkorder_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t Message_HistorySyncNotification::_internal_chunkorder() const {
  return _impl_.chunkorder_;
}
inline uint32_t Message_HistorySyncNotification::chunkorder() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.chunkOrder)
  return _internal_chunkorder();
}
inline void Message_HistorySyncNotification::_internal_set_chunkorder(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.chunkorder_ = value;
}
inline void Message_HistorySyncNotification::set_chunkorder(uint32_t value) {
  _internal_set_chunkorder(value);
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.chunkOrder)
}

// optional string originalMessageId = 8;
inline bool Message_HistorySyncNotification::_internal_has_originalmessageid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_originalmessageid() const {
  return _internal_has_originalmessageid();
}
inline void Message_HistorySyncNotification::clear_originalmessageid() {
  _impl_.originalmessageid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_HistorySyncNotification::originalmessageid() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.originalMessageId)
  return _internal_originalmessageid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_HistorySyncNotification::set_originalmessageid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.originalmessageid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.originalMessageId)
}
inline std::string* Message_HistorySyncNotification::mutable_originalmessageid() {
  std::string* _s = _internal_mutable_originalmessageid();
  // @@protoc_insertion_point(field_mutable:proto.Message.HistorySyncNotification.originalMessageId)
  return _s;
}
inline const std::string& Message_HistorySyncNotification::_internal_originalmessageid() const {
  return _impl_.originalmessageid_.Get();
}
inline void Message_HistorySyncNotification::_internal_set_originalmessageid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.originalmessageid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::_internal_mutable_originalmessageid() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.originalmessageid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_HistorySyncNotification::release_originalmessageid() {
  // @@protoc_insertion_point(field_release:proto.Message.HistorySyncNotification.originalMessageId)
  if (!_internal_has_originalmessageid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.originalmessageid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.originalmessageid_.IsDefault()) {
    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_HistorySyncNotification::set_allocated_originalmessageid(std::string* originalmessageid) {
  if (originalmessageid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.originalmessageid_.SetAllocated(originalmessageid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.originalmessageid_.IsDefault()) {
    _impl_.originalmessageid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.HistorySyncNotification.originalMessageId)
}

// optional uint32 progress = 9;
inline bool Message_HistorySyncNotification::_internal_has_progress() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_HistorySyncNotification::has_progress() const {
  return _internal_has_progress();
}
inline void Message_HistorySyncNotification::clear_progress() {
  _impl_.progress_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t Message_HistorySyncNotification::_internal_progress() const {
  return _impl_.progress_;
}
inline uint32_t Message_HistorySyncNotification::progress() const {
  // @@protoc_insertion_point(field_get:proto.Message.HistorySyncNotification.progress)
  return _internal_progress();
}
inline void Message_HistorySyncNotification::_internal_set_progress(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.progress_ = value;
}
inline void Message_HistorySyncNotification::set_progress(uint32_t value) {
  _internal_set_progress(value);
  // @@protoc_insertion_point(field_set:proto.Message.HistorySyncNotification.progress)
}

// -------------------------------------------------------------------

// Message_ImageMessage

// optional string url = 1;
inline bool Message_ImageMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_ImageMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ImageMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::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:proto.Message.ImageMessage.url)
}
inline std::string* Message_ImageMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.url)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_ImageMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.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 Message_ImageMessage::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:proto.Message.ImageMessage.url)
}

// optional string mimetype = 2;
inline bool Message_ImageMessage::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void Message_ImageMessage::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ImageMessage::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mimetype)
}
inline std::string* Message_ImageMessage::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mimetype)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void Message_ImageMessage::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mimetype)
}

// optional string caption = 3;
inline bool Message_ImageMessage::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_caption() const {
  return _internal_has_caption();
}
inline void Message_ImageMessage::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ImageMessage::caption() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.caption)
}
inline std::string* Message_ImageMessage::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.caption)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void Message_ImageMessage::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_caption() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  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 Message_ImageMessage::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _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:proto.Message.ImageMessage.caption)
}

// optional bytes fileSha256 = 4;
inline bool Message_ImageMessage::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_ImageMessage::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_ImageMessage::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileSha256)
}
inline std::string* Message_ImageMessage::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_ImageMessage::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileSha256)
}

// optional uint64 fileLength = 5;
inline bool Message_ImageMessage::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_ImageMessage::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint64_t Message_ImageMessage::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_ImageMessage::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileLength)
  return _internal_filelength();
}
inline void Message_ImageMessage::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.filelength_ = value;
}
inline void Message_ImageMessage::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileLength)
}

// optional uint32 height = 6;
inline bool Message_ImageMessage::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_height() const {
  return _internal_has_height();
}
inline void Message_ImageMessage::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t Message_ImageMessage::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t Message_ImageMessage::height() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.height)
  return _internal_height();
}
inline void Message_ImageMessage::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.height_ = value;
}
inline void Message_ImageMessage::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.height)
}

// optional uint32 width = 7;
inline bool Message_ImageMessage::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_width() const {
  return _internal_has_width();
}
inline void Message_ImageMessage::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t Message_ImageMessage::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t Message_ImageMessage::width() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.width)
  return _internal_width();
}
inline void Message_ImageMessage::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.width_ = value;
}
inline void Message_ImageMessage::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.width)
}

// optional bytes mediaKey = 8;
inline bool Message_ImageMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_ImageMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_ImageMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKey)
}
inline std::string* Message_ImageMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.mediaKey)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_ImageMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.mediaKey)
}

// optional bytes fileEncSha256 = 9;
inline bool Message_ImageMessage::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_ImageMessage::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_ImageMessage::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.fileEncSha256)
}
inline std::string* Message_ImageMessage::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.fileEncSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_ImageMessage::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.fileEncSha256)
}

// repeated .proto.InteractiveAnnotation interactiveAnnotations = 10;
inline int Message_ImageMessage::_internal_interactiveannotations_size() const {
  return _impl_.interactiveannotations_.size();
}
inline int Message_ImageMessage::interactiveannotations_size() const {
  return _internal_interactiveannotations_size();
}
inline void Message_ImageMessage::clear_interactiveannotations() {
  _impl_.interactiveannotations_.Clear();
}
inline ::proto::InteractiveAnnotation* Message_ImageMessage::mutable_interactiveannotations(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.interactiveAnnotations)
  return _impl_.interactiveannotations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
Message_ImageMessage::mutable_interactiveannotations() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.interactiveAnnotations)
  return &_impl_.interactiveannotations_;
}
inline const ::proto::InteractiveAnnotation& Message_ImageMessage::_internal_interactiveannotations(int index) const {
  return _impl_.interactiveannotations_.Get(index);
}
inline const ::proto::InteractiveAnnotation& Message_ImageMessage::interactiveannotations(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.interactiveAnnotations)
  return _internal_interactiveannotations(index);
}
inline ::proto::InteractiveAnnotation* Message_ImageMessage::_internal_add_interactiveannotations() {
  return _impl_.interactiveannotations_.Add();
}
inline ::proto::InteractiveAnnotation* Message_ImageMessage::add_interactiveannotations() {
  ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations();
  // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.interactiveAnnotations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
Message_ImageMessage::interactiveannotations() const {
  // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.interactiveAnnotations)
  return _impl_.interactiveannotations_;
}

// optional string directPath = 11;
inline bool Message_ImageMessage::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_ImageMessage::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_ImageMessage::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.directPath)
}
inline std::string* Message_ImageMessage::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.directPath)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_ImageMessage::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.directPath)
}

// optional int64 mediaKeyTimestamp = 12;
inline bool Message_ImageMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_ImageMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int64_t Message_ImageMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_ImageMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_ImageMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_ImageMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.mediaKeyTimestamp)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_ImageMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_ImageMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_ImageMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.jpegThumbnail)
}
inline std::string* Message_ImageMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_ImageMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_ImageMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ImageMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ImageMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::proto::ContextInfo& Message_ImageMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ImageMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ImageMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ImageMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ImageMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ImageMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ImageMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ImageMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.contextInfo)
  return _msg;
}
inline void Message_ImageMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.contextInfo)
}

// optional bytes firstScanSidecar = 18;
inline bool Message_ImageMessage::_internal_has_firstscansidecar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_firstscansidecar() const {
  return _internal_has_firstscansidecar();
}
inline void Message_ImageMessage::clear_firstscansidecar() {
  _impl_.firstscansidecar_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Message_ImageMessage::firstscansidecar() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanSidecar)
  return _internal_firstscansidecar();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_firstscansidecar(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.firstscansidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanSidecar)
}
inline std::string* Message_ImageMessage::mutable_firstscansidecar() {
  std::string* _s = _internal_mutable_firstscansidecar();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.firstScanSidecar)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_firstscansidecar() const {
  return _impl_.firstscansidecar_.Get();
}
inline void Message_ImageMessage::_internal_set_firstscansidecar(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.firstscansidecar_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_firstscansidecar() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.firstscansidecar_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_firstscansidecar() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.firstScanSidecar)
  if (!_internal_has_firstscansidecar()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.firstscansidecar_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstscansidecar_.IsDefault()) {
    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_firstscansidecar(std::string* firstscansidecar) {
  if (firstscansidecar != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.firstscansidecar_.SetAllocated(firstscansidecar, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstscansidecar_.IsDefault()) {
    _impl_.firstscansidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.firstScanSidecar)
}

// optional uint32 firstScanLength = 19;
inline bool Message_ImageMessage::_internal_has_firstscanlength() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_firstscanlength() const {
  return _internal_has_firstscanlength();
}
inline void Message_ImageMessage::clear_firstscanlength() {
  _impl_.firstscanlength_ = 0u;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint32_t Message_ImageMessage::_internal_firstscanlength() const {
  return _impl_.firstscanlength_;
}
inline uint32_t Message_ImageMessage::firstscanlength() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.firstScanLength)
  return _internal_firstscanlength();
}
inline void Message_ImageMessage::_internal_set_firstscanlength(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.firstscanlength_ = value;
}
inline void Message_ImageMessage::set_firstscanlength(uint32_t value) {
  _internal_set_firstscanlength(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.firstScanLength)
}

// optional uint32 experimentGroupId = 20;
inline bool Message_ImageMessage::_internal_has_experimentgroupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_experimentgroupid() const {
  return _internal_has_experimentgroupid();
}
inline void Message_ImageMessage::clear_experimentgroupid() {
  _impl_.experimentgroupid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline uint32_t Message_ImageMessage::_internal_experimentgroupid() const {
  return _impl_.experimentgroupid_;
}
inline uint32_t Message_ImageMessage::experimentgroupid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.experimentGroupId)
  return _internal_experimentgroupid();
}
inline void Message_ImageMessage::_internal_set_experimentgroupid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.experimentgroupid_ = value;
}
inline void Message_ImageMessage::set_experimentgroupid(uint32_t value) {
  _internal_set_experimentgroupid(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.experimentGroupId)
}

// optional bytes scansSidecar = 21;
inline bool Message_ImageMessage::_internal_has_scanssidecar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_scanssidecar() const {
  return _internal_has_scanssidecar();
}
inline void Message_ImageMessage::clear_scanssidecar() {
  _impl_.scanssidecar_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Message_ImageMessage::scanssidecar() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scansSidecar)
  return _internal_scanssidecar();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_scanssidecar(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.scanssidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scansSidecar)
}
inline std::string* Message_ImageMessage::mutable_scanssidecar() {
  std::string* _s = _internal_mutable_scanssidecar();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.scansSidecar)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_scanssidecar() const {
  return _impl_.scanssidecar_.Get();
}
inline void Message_ImageMessage::_internal_set_scanssidecar(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.scanssidecar_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_scanssidecar() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.scanssidecar_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_scanssidecar() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.scansSidecar)
  if (!_internal_has_scanssidecar()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.scanssidecar_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.scanssidecar_.IsDefault()) {
    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_scanssidecar(std::string* scanssidecar) {
  if (scanssidecar != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.scanssidecar_.SetAllocated(scanssidecar, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.scanssidecar_.IsDefault()) {
    _impl_.scanssidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.scansSidecar)
}

// repeated uint32 scanLengths = 22;
inline int Message_ImageMessage::_internal_scanlengths_size() const {
  return _impl_.scanlengths_.size();
}
inline int Message_ImageMessage::scanlengths_size() const {
  return _internal_scanlengths_size();
}
inline void Message_ImageMessage::clear_scanlengths() {
  _impl_.scanlengths_.Clear();
}
inline uint32_t Message_ImageMessage::_internal_scanlengths(int index) const {
  return _impl_.scanlengths_.Get(index);
}
inline uint32_t Message_ImageMessage::scanlengths(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.scanLengths)
  return _internal_scanlengths(index);
}
inline void Message_ImageMessage::set_scanlengths(int index, uint32_t value) {
  _impl_.scanlengths_.Set(index, value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.scanLengths)
}
inline void Message_ImageMessage::_internal_add_scanlengths(uint32_t value) {
  _impl_.scanlengths_.Add(value);
}
inline void Message_ImageMessage::add_scanlengths(uint32_t value) {
  _internal_add_scanlengths(value);
  // @@protoc_insertion_point(field_add:proto.Message.ImageMessage.scanLengths)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Message_ImageMessage::_internal_scanlengths() const {
  return _impl_.scanlengths_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
Message_ImageMessage::scanlengths() const {
  // @@protoc_insertion_point(field_list:proto.Message.ImageMessage.scanLengths)
  return _internal_scanlengths();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Message_ImageMessage::_internal_mutable_scanlengths() {
  return &_impl_.scanlengths_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
Message_ImageMessage::mutable_scanlengths() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ImageMessage.scanLengths)
  return _internal_mutable_scanlengths();
}

// optional bytes midQualityFileSha256 = 23;
inline bool Message_ImageMessage::_internal_has_midqualityfilesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_midqualityfilesha256() const {
  return _internal_has_midqualityfilesha256();
}
inline void Message_ImageMessage::clear_midqualityfilesha256() {
  _impl_.midqualityfilesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Message_ImageMessage::midqualityfilesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileSha256)
  return _internal_midqualityfilesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_midqualityfilesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.midqualityfilesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileSha256)
}
inline std::string* Message_ImageMessage::mutable_midqualityfilesha256() {
  std::string* _s = _internal_mutable_midqualityfilesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_midqualityfilesha256() const {
  return _impl_.midqualityfilesha256_.Get();
}
inline void Message_ImageMessage::_internal_set_midqualityfilesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.midqualityfilesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_midqualityfilesha256() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.midqualityfilesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_midqualityfilesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileSha256)
  if (!_internal_has_midqualityfilesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.midqualityfilesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.midqualityfilesha256_.IsDefault()) {
    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_midqualityfilesha256(std::string* midqualityfilesha256) {
  if (midqualityfilesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.midqualityfilesha256_.SetAllocated(midqualityfilesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.midqualityfilesha256_.IsDefault()) {
    _impl_.midqualityfilesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileSha256)
}

// optional bytes midQualityFileEncSha256 = 24;
inline bool Message_ImageMessage::_internal_has_midqualityfileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_midqualityfileencsha256() const {
  return _internal_has_midqualityfileencsha256();
}
inline void Message_ImageMessage::clear_midqualityfileencsha256() {
  _impl_.midqualityfileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Message_ImageMessage::midqualityfileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.midQualityFileEncSha256)
  return _internal_midqualityfileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_midqualityfileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.midqualityfileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.midQualityFileEncSha256)
}
inline std::string* Message_ImageMessage::mutable_midqualityfileencsha256() {
  std::string* _s = _internal_mutable_midqualityfileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.midQualityFileEncSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_midqualityfileencsha256() const {
  return _impl_.midqualityfileencsha256_.Get();
}
inline void Message_ImageMessage::_internal_set_midqualityfileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.midqualityfileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_midqualityfileencsha256() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.midqualityfileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_midqualityfileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.midQualityFileEncSha256)
  if (!_internal_has_midqualityfileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.midqualityfileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.midqualityfileencsha256_.IsDefault()) {
    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_midqualityfileencsha256(std::string* midqualityfileencsha256) {
  if (midqualityfileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.midqualityfileencsha256_.SetAllocated(midqualityfileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.midqualityfileencsha256_.IsDefault()) {
    _impl_.midqualityfileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.midQualityFileEncSha256)
}

// optional bool viewOnce = 25;
inline bool Message_ImageMessage::_internal_has_viewonce() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_viewonce() const {
  return _internal_has_viewonce();
}
inline void Message_ImageMessage::clear_viewonce() {
  _impl_.viewonce_ = false;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool Message_ImageMessage::_internal_viewonce() const {
  return _impl_.viewonce_;
}
inline bool Message_ImageMessage::viewonce() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.viewOnce)
  return _internal_viewonce();
}
inline void Message_ImageMessage::_internal_set_viewonce(bool value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.viewonce_ = value;
}
inline void Message_ImageMessage::set_viewonce(bool value) {
  _internal_set_viewonce(value);
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.viewOnce)
}

// optional string thumbnailDirectPath = 26;
inline bool Message_ImageMessage::_internal_has_thumbnaildirectpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_thumbnaildirectpath() const {
  return _internal_has_thumbnaildirectpath();
}
inline void Message_ImageMessage::clear_thumbnaildirectpath() {
  _impl_.thumbnaildirectpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& Message_ImageMessage::thumbnaildirectpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailDirectPath)
  return _internal_thumbnaildirectpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00001000u;
 _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailDirectPath)
}
inline std::string* Message_ImageMessage::mutable_thumbnaildirectpath() {
  std::string* _s = _internal_mutable_thumbnaildirectpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailDirectPath)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_thumbnaildirectpath() const {
  return _impl_.thumbnaildirectpath_.Get();
}
inline void Message_ImageMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_thumbnaildirectpath() {
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_thumbnaildirectpath() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailDirectPath)
  if (!_internal_has_thumbnaildirectpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  auto* p = _impl_.thumbnaildirectpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
  if (thumbnaildirectpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailDirectPath)
}

// optional bytes thumbnailSha256 = 27;
inline bool Message_ImageMessage::_internal_has_thumbnailsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_thumbnailsha256() const {
  return _internal_has_thumbnailsha256();
}
inline void Message_ImageMessage::clear_thumbnailsha256() {
  _impl_.thumbnailsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const std::string& Message_ImageMessage::thumbnailsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailSha256)
  return _internal_thumbnailsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00002000u;
 _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailSha256)
}
inline std::string* Message_ImageMessage::mutable_thumbnailsha256() {
  std::string* _s = _internal_mutable_thumbnailsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_thumbnailsha256() const {
  return _impl_.thumbnailsha256_.Get();
}
inline void Message_ImageMessage::_internal_set_thumbnailsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_thumbnailsha256() {
  _impl_._has_bits_[0] |= 0x00002000u;
  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_thumbnailsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailSha256)
  if (!_internal_has_thumbnailsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00002000u;
  auto* p = _impl_.thumbnailsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
  if (thumbnailsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailSha256)
}

// optional bytes thumbnailEncSha256 = 28;
inline bool Message_ImageMessage::_internal_has_thumbnailencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_thumbnailencsha256() const {
  return _internal_has_thumbnailencsha256();
}
inline void Message_ImageMessage::clear_thumbnailencsha256() {
  _impl_.thumbnailencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const std::string& Message_ImageMessage::thumbnailencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.thumbnailEncSha256)
  return _internal_thumbnailencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00004000u;
 _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.thumbnailEncSha256)
}
inline std::string* Message_ImageMessage::mutable_thumbnailencsha256() {
  std::string* _s = _internal_mutable_thumbnailencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.thumbnailEncSha256)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_thumbnailencsha256() const {
  return _impl_.thumbnailencsha256_.Get();
}
inline void Message_ImageMessage::_internal_set_thumbnailencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_thumbnailencsha256() {
  _impl_._has_bits_[0] |= 0x00004000u;
  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_thumbnailencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.thumbnailEncSha256)
  if (!_internal_has_thumbnailencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00004000u;
  auto* p = _impl_.thumbnailencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
  if (thumbnailencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.thumbnailEncSha256)
}

// optional string staticUrl = 29;
inline bool Message_ImageMessage::_internal_has_staticurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Message_ImageMessage::has_staticurl() const {
  return _internal_has_staticurl();
}
inline void Message_ImageMessage::clear_staticurl() {
  _impl_.staticurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const std::string& Message_ImageMessage::staticurl() const {
  // @@protoc_insertion_point(field_get:proto.Message.ImageMessage.staticUrl)
  return _internal_staticurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ImageMessage::set_staticurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00008000u;
 _impl_.staticurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ImageMessage.staticUrl)
}
inline std::string* Message_ImageMessage::mutable_staticurl() {
  std::string* _s = _internal_mutable_staticurl();
  // @@protoc_insertion_point(field_mutable:proto.Message.ImageMessage.staticUrl)
  return _s;
}
inline const std::string& Message_ImageMessage::_internal_staticurl() const {
  return _impl_.staticurl_.Get();
}
inline void Message_ImageMessage::_internal_set_staticurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.staticurl_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::_internal_mutable_staticurl() {
  _impl_._has_bits_[0] |= 0x00008000u;
  return _impl_.staticurl_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ImageMessage::release_staticurl() {
  // @@protoc_insertion_point(field_release:proto.Message.ImageMessage.staticUrl)
  if (!_internal_has_staticurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00008000u;
  auto* p = _impl_.staticurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.staticurl_.IsDefault()) {
    _impl_.staticurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ImageMessage::set_allocated_staticurl(std::string* staticurl) {
  if (staticurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.staticurl_.IsDefault()) {
    _impl_.staticurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ImageMessage.staticUrl)
}

// -------------------------------------------------------------------

// Message_InitialSecurityNotificationSettingSync

// optional bool securityNotificationEnabled = 1;
inline bool Message_InitialSecurityNotificationSettingSync::_internal_has_securitynotificationenabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InitialSecurityNotificationSettingSync::has_securitynotificationenabled() const {
  return _internal_has_securitynotificationenabled();
}
inline void Message_InitialSecurityNotificationSettingSync::clear_securitynotificationenabled() {
  _impl_.securitynotificationenabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool Message_InitialSecurityNotificationSettingSync::_internal_securitynotificationenabled() const {
  return _impl_.securitynotificationenabled_;
}
inline bool Message_InitialSecurityNotificationSettingSync::securitynotificationenabled() const {
  // @@protoc_insertion_point(field_get:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled)
  return _internal_securitynotificationenabled();
}
inline void Message_InitialSecurityNotificationSettingSync::_internal_set_securitynotificationenabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.securitynotificationenabled_ = value;
}
inline void Message_InitialSecurityNotificationSettingSync::set_securitynotificationenabled(bool value) {
  _internal_set_securitynotificationenabled(value);
  // @@protoc_insertion_point(field_set:proto.Message.InitialSecurityNotificationSettingSync.securityNotificationEnabled)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_Body

// optional string text = 1;
inline bool Message_InteractiveMessage_Body::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_Body::has_text() const {
  return _internal_has_text();
}
inline void Message_InteractiveMessage_Body::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_Body::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Body.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_Body::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Body.text)
}
inline std::string* Message_InteractiveMessage_Body::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Body.text)
  return _s;
}
inline const std::string& Message_InteractiveMessage_Body::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Message_InteractiveMessage_Body::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Body::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Body::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Body.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveMessage_Body::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveMessage.Body.text)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_CollectionMessage

// optional string bizJid = 1;
inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_bizjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_CollectionMessage::has_bizjid() const {
  return _internal_has_bizjid();
}
inline void Message_InteractiveMessage_CollectionMessage::clear_bizjid() {
  _impl_.bizjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_CollectionMessage::bizjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
  return _internal_bizjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_CollectionMessage::set_bizjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.bizjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
}
inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_bizjid() {
  std::string* _s = _internal_mutable_bizjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
  return _s;
}
inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_bizjid() const {
  return _impl_.bizjid_.Get();
}
inline void Message_InteractiveMessage_CollectionMessage::_internal_set_bizjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.bizjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_bizjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.bizjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_CollectionMessage::release_bizjid() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
  if (!_internal_has_bizjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.bizjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bizjid_.IsDefault()) {
    _impl_.bizjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_CollectionMessage::set_allocated_bizjid(std::string* bizjid) {
  if (bizjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.bizjid_.SetAllocated(bizjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.bizjid_.IsDefault()) {
    _impl_.bizjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.bizJid)
}

// optional string id = 2;
inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_CollectionMessage::has_id() const {
  return _internal_has_id();
}
inline void Message_InteractiveMessage_CollectionMessage::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_InteractiveMessage_CollectionMessage::id() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_CollectionMessage::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.id)
}
inline std::string* Message_InteractiveMessage_CollectionMessage::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.CollectionMessage.id)
  return _s;
}
inline const std::string& Message_InteractiveMessage_CollectionMessage::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Message_InteractiveMessage_CollectionMessage::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_CollectionMessage::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_CollectionMessage::release_id() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.CollectionMessage.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_CollectionMessage::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.CollectionMessage.id)
}

// optional int32 messageVersion = 3;
inline bool Message_InteractiveMessage_CollectionMessage::_internal_has_messageversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_CollectionMessage::has_messageversion() const {
  return _internal_has_messageversion();
}
inline void Message_InteractiveMessage_CollectionMessage::clear_messageversion() {
  _impl_.messageversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Message_InteractiveMessage_CollectionMessage::_internal_messageversion() const {
  return _impl_.messageversion_;
}
inline int32_t Message_InteractiveMessage_CollectionMessage::messageversion() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.CollectionMessage.messageVersion)
  return _internal_messageversion();
}
inline void Message_InteractiveMessage_CollectionMessage::_internal_set_messageversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.messageversion_ = value;
}
inline void Message_InteractiveMessage_CollectionMessage::set_messageversion(int32_t value) {
  _internal_set_messageversion(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.CollectionMessage.messageVersion)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_Footer

// optional string text = 1;
inline bool Message_InteractiveMessage_Footer::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_Footer::has_text() const {
  return _internal_has_text();
}
inline void Message_InteractiveMessage_Footer::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_Footer::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Footer.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_Footer::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Footer.text)
}
inline std::string* Message_InteractiveMessage_Footer::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Footer.text)
  return _s;
}
inline const std::string& Message_InteractiveMessage_Footer::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Message_InteractiveMessage_Footer::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Footer::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Footer::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Footer.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveMessage_Footer::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveMessage.Footer.text)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_Header

// optional string title = 1;
inline bool Message_InteractiveMessage_Header::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_Header::has_title() const {
  return _internal_has_title();
}
inline void Message_InteractiveMessage_Header::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_Header::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_Header::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.title)
}
inline std::string* Message_InteractiveMessage_Header::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.title)
  return _s;
}
inline const std::string& Message_InteractiveMessage_Header::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_InteractiveMessage_Header::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveMessage_Header::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveMessage.Header.title)
}

// optional string subtitle = 2;
inline bool Message_InteractiveMessage_Header::_internal_has_subtitle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_Header::has_subtitle() const {
  return _internal_has_subtitle();
}
inline void Message_InteractiveMessage_Header::clear_subtitle() {
  _impl_.subtitle_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_InteractiveMessage_Header::subtitle() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.subtitle)
  return _internal_subtitle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_Header::set_subtitle(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.subtitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.subtitle)
}
inline std::string* Message_InteractiveMessage_Header::mutable_subtitle() {
  std::string* _s = _internal_mutable_subtitle();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.subtitle)
  return _s;
}
inline const std::string& Message_InteractiveMessage_Header::_internal_subtitle() const {
  return _impl_.subtitle_.Get();
}
inline void Message_InteractiveMessage_Header::_internal_set_subtitle(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.subtitle_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::_internal_mutable_subtitle() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.subtitle_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::release_subtitle() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.subtitle)
  if (!_internal_has_subtitle()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.subtitle_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.subtitle_.IsDefault()) {
    _impl_.subtitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_Header::set_allocated_subtitle(std::string* subtitle) {
  if (subtitle != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.subtitle_.SetAllocated(subtitle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.subtitle_.IsDefault()) {
    _impl_.subtitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.subtitle)
}

// optional bool hasMediaAttachment = 5;
inline bool Message_InteractiveMessage_Header::_internal_has_hasmediaattachment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_Header::has_hasmediaattachment() const {
  return _internal_has_hasmediaattachment();
}
inline void Message_InteractiveMessage_Header::clear_hasmediaattachment() {
  _impl_.hasmediaattachment_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool Message_InteractiveMessage_Header::_internal_hasmediaattachment() const {
  return _impl_.hasmediaattachment_;
}
inline bool Message_InteractiveMessage_Header::hasmediaattachment() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.hasMediaAttachment)
  return _internal_hasmediaattachment();
}
inline void Message_InteractiveMessage_Header::_internal_set_hasmediaattachment(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.hasmediaattachment_ = value;
}
inline void Message_InteractiveMessage_Header::set_hasmediaattachment(bool value) {
  _internal_set_hasmediaattachment(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.hasMediaAttachment)
}

// .proto.Message.DocumentMessage documentMessage = 3;
inline bool Message_InteractiveMessage_Header::_internal_has_documentmessage() const {
  return media_case() == kDocumentMessage;
}
inline bool Message_InteractiveMessage_Header::has_documentmessage() const {
  return _internal_has_documentmessage();
}
inline void Message_InteractiveMessage_Header::set_has_documentmessage() {
  _impl_._oneof_case_[0] = kDocumentMessage;
}
inline void Message_InteractiveMessage_Header::clear_documentmessage() {
  if (_internal_has_documentmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.media_.documentmessage_;
    }
    clear_has_media();
  }
}
inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::release_documentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_media();
    ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.media_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::_internal_documentmessage() const {
  return _internal_has_documentmessage()
      ? *_impl_.media_.documentmessage_
      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
}
inline const ::proto::Message_DocumentMessage& Message_InteractiveMessage_Header::documentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.documentMessage)
  return _internal_documentmessage();
}
inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::unsafe_arena_release_documentmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_media();
    ::proto::Message_DocumentMessage* temp = _impl_.media_.documentmessage_;
    _impl_.media_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
  clear_media();
  if (documentmessage) {
    set_has_documentmessage();
    _impl_.media_.documentmessage_ = documentmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.documentMessage)
}
inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::_internal_mutable_documentmessage() {
  if (!_internal_has_documentmessage()) {
    clear_media();
    set_has_documentmessage();
    _impl_.media_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
  }
  return _impl_.media_.documentmessage_;
}
inline ::proto::Message_DocumentMessage* Message_InteractiveMessage_Header::mutable_documentmessage() {
  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.documentMessage)
  return _msg;
}

// .proto.Message.ImageMessage imageMessage = 4;
inline bool Message_InteractiveMessage_Header::_internal_has_imagemessage() const {
  return media_case() == kImageMessage;
}
inline bool Message_InteractiveMessage_Header::has_imagemessage() const {
  return _internal_has_imagemessage();
}
inline void Message_InteractiveMessage_Header::set_has_imagemessage() {
  _impl_._oneof_case_[0] = kImageMessage;
}
inline void Message_InteractiveMessage_Header::clear_imagemessage() {
  if (_internal_has_imagemessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.media_.imagemessage_;
    }
    clear_has_media();
  }
}
inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::release_imagemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_media();
    ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.media_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::_internal_imagemessage() const {
  return _internal_has_imagemessage()
      ? *_impl_.media_.imagemessage_
      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_InteractiveMessage_Header::imagemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.imageMessage)
  return _internal_imagemessage();
}
inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::unsafe_arena_release_imagemessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_media();
    ::proto::Message_ImageMessage* temp = _impl_.media_.imagemessage_;
    _impl_.media_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
  clear_media();
  if (imagemessage) {
    set_has_imagemessage();
    _impl_.media_.imagemessage_ = imagemessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.imageMessage)
}
inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::_internal_mutable_imagemessage() {
  if (!_internal_has_imagemessage()) {
    clear_media();
    set_has_imagemessage();
    _impl_.media_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
  }
  return _impl_.media_.imagemessage_;
}
inline ::proto::Message_ImageMessage* Message_InteractiveMessage_Header::mutable_imagemessage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.imageMessage)
  return _msg;
}

// bytes jpegThumbnail = 6;
inline bool Message_InteractiveMessage_Header::_internal_has_jpegthumbnail() const {
  return media_case() == kJpegThumbnail;
}
inline bool Message_InteractiveMessage_Header::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_InteractiveMessage_Header::set_has_jpegthumbnail() {
  _impl_._oneof_case_[0] = kJpegThumbnail;
}
inline void Message_InteractiveMessage_Header::clear_jpegthumbnail() {
  if (_internal_has_jpegthumbnail()) {
    _impl_.media_.jpegthumbnail_.Destroy();
    clear_has_media();
  }
}
inline const std::string& Message_InteractiveMessage_Header::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline void Message_InteractiveMessage_Header::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_jpegthumbnail()) {
    clear_media();
    set_has_jpegthumbnail();
    _impl_.media_.jpegthumbnail_.InitDefault();
  }
  _impl_.media_.jpegthumbnail_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.Header.jpegThumbnail)
}
inline std::string* Message_InteractiveMessage_Header::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.jpegThumbnail)
  return _s;
}
inline const std::string& Message_InteractiveMessage_Header::_internal_jpegthumbnail() const {
  if (_internal_has_jpegthumbnail()) {
    return _impl_.media_.jpegthumbnail_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Message_InteractiveMessage_Header::_internal_set_jpegthumbnail(const std::string& value) {
  if (!_internal_has_jpegthumbnail()) {
    clear_media();
    set_has_jpegthumbnail();
    _impl_.media_.jpegthumbnail_.InitDefault();
  }
  _impl_.media_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::_internal_mutable_jpegthumbnail() {
  if (!_internal_has_jpegthumbnail()) {
    clear_media();
    set_has_jpegthumbnail();
    _impl_.media_.jpegthumbnail_.InitDefault();
  }
  return _impl_.media_.jpegthumbnail_.Mutable(      GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_Header::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.jpegThumbnail)
  if (_internal_has_jpegthumbnail()) {
    clear_has_media();
    return _impl_.media_.jpegthumbnail_.Release();
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage_Header::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (has_media()) {
    clear_media();
  }
  if (jpegthumbnail != nullptr) {
    set_has_jpegthumbnail();
    _impl_.media_.jpegthumbnail_.InitAllocated(jpegthumbnail, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.Header.jpegThumbnail)
}

// .proto.Message.VideoMessage videoMessage = 7;
inline bool Message_InteractiveMessage_Header::_internal_has_videomessage() const {
  return media_case() == kVideoMessage;
}
inline bool Message_InteractiveMessage_Header::has_videomessage() const {
  return _internal_has_videomessage();
}
inline void Message_InteractiveMessage_Header::set_has_videomessage() {
  _impl_._oneof_case_[0] = kVideoMessage;
}
inline void Message_InteractiveMessage_Header::clear_videomessage() {
  if (_internal_has_videomessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.media_.videomessage_;
    }
    clear_has_media();
  }
}
inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::release_videomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.Header.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_media();
    ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.media_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::_internal_videomessage() const {
  return _internal_has_videomessage()
      ? *_impl_.media_.videomessage_
      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
}
inline const ::proto::Message_VideoMessage& Message_InteractiveMessage_Header::videomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.Header.videoMessage)
  return _internal_videomessage();
}
inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::unsafe_arena_release_videomessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.Header.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_media();
    ::proto::Message_VideoMessage* temp = _impl_.media_.videomessage_;
    _impl_.media_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage_Header::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
  clear_media();
  if (videomessage) {
    set_has_videomessage();
    _impl_.media_.videomessage_ = videomessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.Header.videoMessage)
}
inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::_internal_mutable_videomessage() {
  if (!_internal_has_videomessage()) {
    clear_media();
    set_has_videomessage();
    _impl_.media_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
  }
  return _impl_.media_.videomessage_;
}
inline ::proto::Message_VideoMessage* Message_InteractiveMessage_Header::mutable_videomessage() {
  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.Header.videoMessage)
  return _msg;
}

inline bool Message_InteractiveMessage_Header::has_media() const {
  return media_case() != MEDIA_NOT_SET;
}
inline void Message_InteractiveMessage_Header::clear_has_media() {
  _impl_._oneof_case_[0] = MEDIA_NOT_SET;
}
inline Message_InteractiveMessage_Header::MediaCase Message_InteractiveMessage_Header::media_case() const {
  return Message_InteractiveMessage_Header::MediaCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton

// optional string name = 1;
inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_name() const {
  return _internal_has_name();
}
inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::name() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
  return _s;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_name() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.name)
}

// optional string buttonParamsJson = 2;
inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_has_buttonparamsjson() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::has_buttonparamsjson() const {
  return _internal_has_buttonparamsjson();
}
inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::clear_buttonparamsjson() {
  _impl_.buttonparamsjson_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::buttonparamsjson() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
  return _internal_buttonparamsjson();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_buttonparamsjson(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.buttonparamsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::mutable_buttonparamsjson() {
  std::string* _s = _internal_mutable_buttonparamsjson();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
  return _s;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_buttonparamsjson() const {
  return _impl_.buttonparamsjson_.Get();
}
inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_set_buttonparamsjson(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.buttonparamsjson_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::_internal_mutable_buttonparamsjson() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.buttonparamsjson_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::release_buttonparamsjson() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
  if (!_internal_has_buttonparamsjson()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.buttonparamsjson_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttonparamsjson_.IsDefault()) {
    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton::set_allocated_buttonparamsjson(std::string* buttonparamsjson) {
  if (buttonparamsjson != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.buttonparamsjson_.SetAllocated(buttonparamsjson, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttonparamsjson_.IsDefault()) {
    _impl_.buttonparamsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton.buttonParamsJson)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_NativeFlowMessage

// repeated .proto.Message.InteractiveMessage.NativeFlowMessage.NativeFlowButton buttons = 1;
inline int Message_InteractiveMessage_NativeFlowMessage::_internal_buttons_size() const {
  return _impl_.buttons_.size();
}
inline int Message_InteractiveMessage_NativeFlowMessage::buttons_size() const {
  return _internal_buttons_size();
}
inline void Message_InteractiveMessage_NativeFlowMessage::clear_buttons() {
  _impl_.buttons_.Clear();
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::mutable_buttons(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
  return _impl_.buttons_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >*
Message_InteractiveMessage_NativeFlowMessage::mutable_buttons() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
  return &_impl_.buttons_;
}
inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::_internal_buttons(int index) const {
  return _impl_.buttons_.Get(index);
}
inline const ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton& Message_InteractiveMessage_NativeFlowMessage::buttons(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
  return _internal_buttons(index);
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::_internal_add_buttons() {
  return _impl_.buttons_.Add();
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* Message_InteractiveMessage_NativeFlowMessage::add_buttons() {
  ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton* _add = _internal_add_buttons();
  // @@protoc_insertion_point(field_add:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_InteractiveMessage_NativeFlowMessage_NativeFlowButton >&
Message_InteractiveMessage_NativeFlowMessage::buttons() const {
  // @@protoc_insertion_point(field_list:proto.Message.InteractiveMessage.NativeFlowMessage.buttons)
  return _impl_.buttons_;
}

// optional string messageParamsJson = 2;
inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageparamsjson() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageparamsjson() const {
  return _internal_has_messageparamsjson();
}
inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageparamsjson() {
  _impl_.messageparamsjson_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage::messageparamsjson() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
  return _internal_messageparamsjson();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_NativeFlowMessage::set_messageparamsjson(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.messageparamsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage::mutable_messageparamsjson() {
  std::string* _s = _internal_mutable_messageparamsjson();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
  return _s;
}
inline const std::string& Message_InteractiveMessage_NativeFlowMessage::_internal_messageparamsjson() const {
  return _impl_.messageparamsjson_.Get();
}
inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageparamsjson(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.messageparamsjson_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage::_internal_mutable_messageparamsjson() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.messageparamsjson_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_NativeFlowMessage::release_messageparamsjson() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
  if (!_internal_has_messageparamsjson()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.messageparamsjson_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messageparamsjson_.IsDefault()) {
    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_NativeFlowMessage::set_allocated_messageparamsjson(std::string* messageparamsjson) {
  if (messageparamsjson != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messageparamsjson_.SetAllocated(messageparamsjson, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messageparamsjson_.IsDefault()) {
    _impl_.messageparamsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.NativeFlowMessage.messageParamsJson)
}

// optional int32 messageVersion = 3;
inline bool Message_InteractiveMessage_NativeFlowMessage::_internal_has_messageversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_NativeFlowMessage::has_messageversion() const {
  return _internal_has_messageversion();
}
inline void Message_InteractiveMessage_NativeFlowMessage::clear_messageversion() {
  _impl_.messageversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Message_InteractiveMessage_NativeFlowMessage::_internal_messageversion() const {
  return _impl_.messageversion_;
}
inline int32_t Message_InteractiveMessage_NativeFlowMessage::messageversion() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion)
  return _internal_messageversion();
}
inline void Message_InteractiveMessage_NativeFlowMessage::_internal_set_messageversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.messageversion_ = value;
}
inline void Message_InteractiveMessage_NativeFlowMessage::set_messageversion(int32_t value) {
  _internal_set_messageversion(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.NativeFlowMessage.messageVersion)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage_ShopMessage

// optional string id = 1;
inline bool Message_InteractiveMessage_ShopMessage::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_ShopMessage::has_id() const {
  return _internal_has_id();
}
inline void Message_InteractiveMessage_ShopMessage::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveMessage_ShopMessage::id() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveMessage_ShopMessage::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.id)
}
inline std::string* Message_InteractiveMessage_ShopMessage::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.ShopMessage.id)
  return _s;
}
inline const std::string& Message_InteractiveMessage_ShopMessage::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Message_InteractiveMessage_ShopMessage::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_ShopMessage::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveMessage_ShopMessage::release_id() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.ShopMessage.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveMessage_ShopMessage::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.ShopMessage.id)
}

// optional .proto.Message.InteractiveMessage.ShopMessage.Surface surface = 2;
inline bool Message_InteractiveMessage_ShopMessage::_internal_has_surface() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_ShopMessage::has_surface() const {
  return _internal_has_surface();
}
inline void Message_InteractiveMessage_ShopMessage::clear_surface() {
  _impl_.surface_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::_internal_surface() const {
  return static_cast< ::proto::Message_InteractiveMessage_ShopMessage_Surface >(_impl_.surface_);
}
inline ::proto::Message_InteractiveMessage_ShopMessage_Surface Message_InteractiveMessage_ShopMessage::surface() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.surface)
  return _internal_surface();
}
inline void Message_InteractiveMessage_ShopMessage::_internal_set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) {
  assert(::proto::Message_InteractiveMessage_ShopMessage_Surface_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.surface_ = value;
}
inline void Message_InteractiveMessage_ShopMessage::set_surface(::proto::Message_InteractiveMessage_ShopMessage_Surface value) {
  _internal_set_surface(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.surface)
}

// optional int32 messageVersion = 3;
inline bool Message_InteractiveMessage_ShopMessage::_internal_has_messageversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_InteractiveMessage_ShopMessage::has_messageversion() const {
  return _internal_has_messageversion();
}
inline void Message_InteractiveMessage_ShopMessage::clear_messageversion() {
  _impl_.messageversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Message_InteractiveMessage_ShopMessage::_internal_messageversion() const {
  return _impl_.messageversion_;
}
inline int32_t Message_InteractiveMessage_ShopMessage::messageversion() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.ShopMessage.messageVersion)
  return _internal_messageversion();
}
inline void Message_InteractiveMessage_ShopMessage::_internal_set_messageversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.messageversion_ = value;
}
inline void Message_InteractiveMessage_ShopMessage::set_messageversion(int32_t value) {
  _internal_set_messageversion(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveMessage.ShopMessage.messageVersion)
}

// -------------------------------------------------------------------

// Message_InteractiveMessage

// optional .proto.Message.InteractiveMessage.Header header = 1;
inline bool Message_InteractiveMessage::_internal_has_header() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.header_ != nullptr);
  return value;
}
inline bool Message_InteractiveMessage::has_header() const {
  return _internal_has_header();
}
inline void Message_InteractiveMessage::clear_header() {
  if (_impl_.header_ != nullptr) _impl_.header_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::_internal_header() const {
  const ::proto::Message_InteractiveMessage_Header* p = _impl_.header_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Header&>(
      ::proto::_Message_InteractiveMessage_Header_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_Header& Message_InteractiveMessage::header() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.header)
  return _internal_header();
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_header(
    ::proto::Message_InteractiveMessage_Header* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.header_);
  }
  _impl_.header_ = header;
  if (header) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.header)
}
inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::release_header() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_;
  _impl_.header_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.header)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_InteractiveMessage_Header* temp = _impl_.header_;
  _impl_.header_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::_internal_mutable_header() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.header_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Header>(GetArenaForAllocation());
    _impl_.header_ = p;
  }
  return _impl_.header_;
}
inline ::proto::Message_InteractiveMessage_Header* Message_InteractiveMessage::mutable_header() {
  ::proto::Message_InteractiveMessage_Header* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.header)
  return _msg;
}
inline void Message_InteractiveMessage::set_allocated_header(::proto::Message_InteractiveMessage_Header* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.header_;
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(header);
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.header_ = header;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.header)
}

// optional .proto.Message.InteractiveMessage.Body body = 2;
inline bool Message_InteractiveMessage::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr);
  return value;
}
inline bool Message_InteractiveMessage::has_body() const {
  return _internal_has_body();
}
inline void Message_InteractiveMessage::clear_body() {
  if (_impl_.body_ != nullptr) _impl_.body_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::_internal_body() const {
  const ::proto::Message_InteractiveMessage_Body* p = _impl_.body_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Body&>(
      ::proto::_Message_InteractiveMessage_Body_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_Body& Message_InteractiveMessage::body() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.body)
  return _internal_body();
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_body(
    ::proto::Message_InteractiveMessage_Body* body) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_);
  }
  _impl_.body_ = body;
  if (body) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.body)
}
inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::release_body() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_;
  _impl_.body_ = 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 ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::unsafe_arena_release_body() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.body)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_InteractiveMessage_Body* temp = _impl_.body_;
  _impl_.body_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.body_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Body>(GetArenaForAllocation());
    _impl_.body_ = p;
  }
  return _impl_.body_;
}
inline ::proto::Message_InteractiveMessage_Body* Message_InteractiveMessage::mutable_body() {
  ::proto::Message_InteractiveMessage_Body* _msg = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.body)
  return _msg;
}
inline void Message_InteractiveMessage::set_allocated_body(::proto::Message_InteractiveMessage_Body* body) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.body_;
  }
  if (body) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body);
    if (message_arena != submessage_arena) {
      body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, body, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.body_ = body;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.body)
}

// optional .proto.Message.InteractiveMessage.Footer footer = 3;
inline bool Message_InteractiveMessage::_internal_has_footer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr);
  return value;
}
inline bool Message_InteractiveMessage::has_footer() const {
  return _internal_has_footer();
}
inline void Message_InteractiveMessage::clear_footer() {
  if (_impl_.footer_ != nullptr) _impl_.footer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::_internal_footer() const {
  const ::proto::Message_InteractiveMessage_Footer* p = _impl_.footer_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage_Footer&>(
      ::proto::_Message_InteractiveMessage_Footer_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_Footer& Message_InteractiveMessage::footer() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.footer)
  return _internal_footer();
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_footer(
    ::proto::Message_InteractiveMessage_Footer* footer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_);
  }
  _impl_.footer_ = footer;
  if (footer) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.footer)
}
inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::release_footer() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_;
  _impl_.footer_ = 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 ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::unsafe_arena_release_footer() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.footer)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_InteractiveMessage_Footer* temp = _impl_.footer_;
  _impl_.footer_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::_internal_mutable_footer() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.footer_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage_Footer>(GetArenaForAllocation());
    _impl_.footer_ = p;
  }
  return _impl_.footer_;
}
inline ::proto::Message_InteractiveMessage_Footer* Message_InteractiveMessage::mutable_footer() {
  ::proto::Message_InteractiveMessage_Footer* _msg = _internal_mutable_footer();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.footer)
  return _msg;
}
inline void Message_InteractiveMessage::set_allocated_footer(::proto::Message_InteractiveMessage_Footer* footer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.footer_;
  }
  if (footer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer);
    if (message_arena != submessage_arena) {
      footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, footer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.footer_ = footer;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.footer)
}

// optional .proto.ContextInfo contextInfo = 15;
inline bool Message_InteractiveMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_InteractiveMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_InteractiveMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::ContextInfo& Message_InteractiveMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_InteractiveMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_InteractiveMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_InteractiveMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_InteractiveMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_InteractiveMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.contextInfo)
  return _msg;
}
inline void Message_InteractiveMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveMessage.contextInfo)
}

// .proto.Message.InteractiveMessage.ShopMessage shopStorefrontMessage = 4;
inline bool Message_InteractiveMessage::_internal_has_shopstorefrontmessage() const {
  return interactiveMessage_case() == kShopStorefrontMessage;
}
inline bool Message_InteractiveMessage::has_shopstorefrontmessage() const {
  return _internal_has_shopstorefrontmessage();
}
inline void Message_InteractiveMessage::set_has_shopstorefrontmessage() {
  _impl_._oneof_case_[0] = kShopStorefrontMessage;
}
inline void Message_InteractiveMessage::clear_shopstorefrontmessage() {
  if (_internal_has_shopstorefrontmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.interactiveMessage_.shopstorefrontmessage_;
    }
    clear_has_interactiveMessage();
  }
}
inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::release_shopstorefrontmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.shopStorefrontMessage)
  if (_internal_has_shopstorefrontmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::_internal_shopstorefrontmessage() const {
  return _internal_has_shopstorefrontmessage()
      ? *_impl_.interactiveMessage_.shopstorefrontmessage_
      : reinterpret_cast< ::proto::Message_InteractiveMessage_ShopMessage&>(::proto::_Message_InteractiveMessage_ShopMessage_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_ShopMessage& Message_InteractiveMessage::shopstorefrontmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.shopStorefrontMessage)
  return _internal_shopstorefrontmessage();
}
inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::unsafe_arena_release_shopstorefrontmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.shopStorefrontMessage)
  if (_internal_has_shopstorefrontmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_ShopMessage* temp = _impl_.interactiveMessage_.shopstorefrontmessage_;
    _impl_.interactiveMessage_.shopstorefrontmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_shopstorefrontmessage(::proto::Message_InteractiveMessage_ShopMessage* shopstorefrontmessage) {
  clear_interactiveMessage();
  if (shopstorefrontmessage) {
    set_has_shopstorefrontmessage();
    _impl_.interactiveMessage_.shopstorefrontmessage_ = shopstorefrontmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.shopStorefrontMessage)
}
inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::_internal_mutable_shopstorefrontmessage() {
  if (!_internal_has_shopstorefrontmessage()) {
    clear_interactiveMessage();
    set_has_shopstorefrontmessage();
    _impl_.interactiveMessage_.shopstorefrontmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_ShopMessage >(GetArenaForAllocation());
  }
  return _impl_.interactiveMessage_.shopstorefrontmessage_;
}
inline ::proto::Message_InteractiveMessage_ShopMessage* Message_InteractiveMessage::mutable_shopstorefrontmessage() {
  ::proto::Message_InteractiveMessage_ShopMessage* _msg = _internal_mutable_shopstorefrontmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.shopStorefrontMessage)
  return _msg;
}

// .proto.Message.InteractiveMessage.CollectionMessage collectionMessage = 5;
inline bool Message_InteractiveMessage::_internal_has_collectionmessage() const {
  return interactiveMessage_case() == kCollectionMessage;
}
inline bool Message_InteractiveMessage::has_collectionmessage() const {
  return _internal_has_collectionmessage();
}
inline void Message_InteractiveMessage::set_has_collectionmessage() {
  _impl_._oneof_case_[0] = kCollectionMessage;
}
inline void Message_InteractiveMessage::clear_collectionmessage() {
  if (_internal_has_collectionmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.interactiveMessage_.collectionmessage_;
    }
    clear_has_interactiveMessage();
  }
}
inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::release_collectionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.collectionMessage)
  if (_internal_has_collectionmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.interactiveMessage_.collectionmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::_internal_collectionmessage() const {
  return _internal_has_collectionmessage()
      ? *_impl_.interactiveMessage_.collectionmessage_
      : reinterpret_cast< ::proto::Message_InteractiveMessage_CollectionMessage&>(::proto::_Message_InteractiveMessage_CollectionMessage_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_CollectionMessage& Message_InteractiveMessage::collectionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.collectionMessage)
  return _internal_collectionmessage();
}
inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::unsafe_arena_release_collectionmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.collectionMessage)
  if (_internal_has_collectionmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_CollectionMessage* temp = _impl_.interactiveMessage_.collectionmessage_;
    _impl_.interactiveMessage_.collectionmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_collectionmessage(::proto::Message_InteractiveMessage_CollectionMessage* collectionmessage) {
  clear_interactiveMessage();
  if (collectionmessage) {
    set_has_collectionmessage();
    _impl_.interactiveMessage_.collectionmessage_ = collectionmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.collectionMessage)
}
inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::_internal_mutable_collectionmessage() {
  if (!_internal_has_collectionmessage()) {
    clear_interactiveMessage();
    set_has_collectionmessage();
    _impl_.interactiveMessage_.collectionmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_CollectionMessage >(GetArenaForAllocation());
  }
  return _impl_.interactiveMessage_.collectionmessage_;
}
inline ::proto::Message_InteractiveMessage_CollectionMessage* Message_InteractiveMessage::mutable_collectionmessage() {
  ::proto::Message_InteractiveMessage_CollectionMessage* _msg = _internal_mutable_collectionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.collectionMessage)
  return _msg;
}

// .proto.Message.InteractiveMessage.NativeFlowMessage nativeFlowMessage = 6;
inline bool Message_InteractiveMessage::_internal_has_nativeflowmessage() const {
  return interactiveMessage_case() == kNativeFlowMessage;
}
inline bool Message_InteractiveMessage::has_nativeflowmessage() const {
  return _internal_has_nativeflowmessage();
}
inline void Message_InteractiveMessage::set_has_nativeflowmessage() {
  _impl_._oneof_case_[0] = kNativeFlowMessage;
}
inline void Message_InteractiveMessage::clear_nativeflowmessage() {
  if (_internal_has_nativeflowmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.interactiveMessage_.nativeflowmessage_;
    }
    clear_has_interactiveMessage();
  }
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::release_nativeflowmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveMessage.nativeFlowMessage)
  if (_internal_has_nativeflowmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.interactiveMessage_.nativeflowmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::_internal_nativeflowmessage() const {
  return _internal_has_nativeflowmessage()
      ? *_impl_.interactiveMessage_.nativeflowmessage_
      : reinterpret_cast< ::proto::Message_InteractiveMessage_NativeFlowMessage&>(::proto::_Message_InteractiveMessage_NativeFlowMessage_default_instance_);
}
inline const ::proto::Message_InteractiveMessage_NativeFlowMessage& Message_InteractiveMessage::nativeflowmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveMessage.nativeFlowMessage)
  return _internal_nativeflowmessage();
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::unsafe_arena_release_nativeflowmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveMessage.nativeFlowMessage)
  if (_internal_has_nativeflowmessage()) {
    clear_has_interactiveMessage();
    ::proto::Message_InteractiveMessage_NativeFlowMessage* temp = _impl_.interactiveMessage_.nativeflowmessage_;
    _impl_.interactiveMessage_.nativeflowmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveMessage::unsafe_arena_set_allocated_nativeflowmessage(::proto::Message_InteractiveMessage_NativeFlowMessage* nativeflowmessage) {
  clear_interactiveMessage();
  if (nativeflowmessage) {
    set_has_nativeflowmessage();
    _impl_.interactiveMessage_.nativeflowmessage_ = nativeflowmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveMessage.nativeFlowMessage)
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::_internal_mutable_nativeflowmessage() {
  if (!_internal_has_nativeflowmessage()) {
    clear_interactiveMessage();
    set_has_nativeflowmessage();
    _impl_.interactiveMessage_.nativeflowmessage_ = CreateMaybeMessage< ::proto::Message_InteractiveMessage_NativeFlowMessage >(GetArenaForAllocation());
  }
  return _impl_.interactiveMessage_.nativeflowmessage_;
}
inline ::proto::Message_InteractiveMessage_NativeFlowMessage* Message_InteractiveMessage::mutable_nativeflowmessage() {
  ::proto::Message_InteractiveMessage_NativeFlowMessage* _msg = _internal_mutable_nativeflowmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveMessage.nativeFlowMessage)
  return _msg;
}

inline bool Message_InteractiveMessage::has_interactiveMessage() const {
  return interactiveMessage_case() != INTERACTIVEMESSAGE_NOT_SET;
}
inline void Message_InteractiveMessage::clear_has_interactiveMessage() {
  _impl_._oneof_case_[0] = INTERACTIVEMESSAGE_NOT_SET;
}
inline Message_InteractiveMessage::InteractiveMessageCase Message_InteractiveMessage::interactiveMessage_case() const {
  return Message_InteractiveMessage::InteractiveMessageCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_InteractiveResponseMessage_Body

// optional string text = 1;
inline bool Message_InteractiveResponseMessage_Body::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveResponseMessage_Body::has_text() const {
  return _internal_has_text();
}
inline void Message_InteractiveResponseMessage_Body::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveResponseMessage_Body::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.Body.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveResponseMessage_Body::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.Body.text)
}
inline std::string* Message_InteractiveResponseMessage_Body::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.Body.text)
  return _s;
}
inline const std::string& Message_InteractiveResponseMessage_Body::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Message_InteractiveResponseMessage_Body::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_Body::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_Body::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.Body.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveResponseMessage_Body::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveResponseMessage.Body.text)
}

// -------------------------------------------------------------------

// Message_InteractiveResponseMessage_NativeFlowResponseMessage

// optional string name = 1;
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_name() const {
  return _internal_has_name();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::name() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
  return _s;
}
inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_name() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.name)
}

// optional string paramsJson = 2;
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_paramsjson() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_paramsjson() const {
  return _internal_has_paramsjson();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_paramsjson() {
  _impl_.paramsjson_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::paramsjson() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
  return _internal_paramsjson();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_paramsjson(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.paramsjson_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::mutable_paramsjson() {
  std::string* _s = _internal_mutable_paramsjson();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
  return _s;
}
inline const std::string& Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_paramsjson() const {
  return _impl_.paramsjson_.Get();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_paramsjson(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.paramsjson_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_mutable_paramsjson() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.paramsjson_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InteractiveResponseMessage_NativeFlowResponseMessage::release_paramsjson() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
  if (!_internal_has_paramsjson()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.paramsjson_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paramsjson_.IsDefault()) {
    _impl_.paramsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_allocated_paramsjson(std::string* paramsjson) {
  if (paramsjson != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.paramsjson_.SetAllocated(paramsjson, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paramsjson_.IsDefault()) {
    _impl_.paramsjson_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.paramsJson)
}

// optional int32 version = 3;
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_InteractiveResponseMessage_NativeFlowResponseMessage::has_version() const {
  return _internal_has_version();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::clear_version() {
  _impl_.version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_version() const {
  return _impl_.version_;
}
inline int32_t Message_InteractiveResponseMessage_NativeFlowResponseMessage::version() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version)
  return _internal_version();
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.version_ = value;
}
inline void Message_InteractiveResponseMessage_NativeFlowResponseMessage::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage.version)
}

// -------------------------------------------------------------------

// Message_InteractiveResponseMessage

// optional .proto.Message.InteractiveResponseMessage.Body body = 1;
inline bool Message_InteractiveResponseMessage::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.body_ != nullptr);
  return value;
}
inline bool Message_InteractiveResponseMessage::has_body() const {
  return _internal_has_body();
}
inline void Message_InteractiveResponseMessage::clear_body() {
  if (_impl_.body_ != nullptr) _impl_.body_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::_internal_body() const {
  const ::proto::Message_InteractiveResponseMessage_Body* p = _impl_.body_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveResponseMessage_Body&>(
      ::proto::_Message_InteractiveResponseMessage_Body_default_instance_);
}
inline const ::proto::Message_InteractiveResponseMessage_Body& Message_InteractiveResponseMessage::body() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.body)
  return _internal_body();
}
inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_body(
    ::proto::Message_InteractiveResponseMessage_Body* body) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.body_);
  }
  _impl_.body_ = body;
  if (body) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.body)
}
inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::release_body() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_;
  _impl_.body_ = 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 ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::unsafe_arena_release_body() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.body)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_InteractiveResponseMessage_Body* temp = _impl_.body_;
  _impl_.body_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.body_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage_Body>(GetArenaForAllocation());
    _impl_.body_ = p;
  }
  return _impl_.body_;
}
inline ::proto::Message_InteractiveResponseMessage_Body* Message_InteractiveResponseMessage::mutable_body() {
  ::proto::Message_InteractiveResponseMessage_Body* _msg = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.body)
  return _msg;
}
inline void Message_InteractiveResponseMessage::set_allocated_body(::proto::Message_InteractiveResponseMessage_Body* body) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.body_;
  }
  if (body) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(body);
    if (message_arena != submessage_arena) {
      body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, body, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.body_ = body;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.body)
}

// optional .proto.ContextInfo contextInfo = 15;
inline bool Message_InteractiveResponseMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_InteractiveResponseMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_InteractiveResponseMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_InteractiveResponseMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_InteractiveResponseMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_InteractiveResponseMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_InteractiveResponseMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_InteractiveResponseMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.contextInfo)
  return _msg;
}
inline void Message_InteractiveResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InteractiveResponseMessage.contextInfo)
}

// .proto.Message.InteractiveResponseMessage.NativeFlowResponseMessage nativeFlowResponseMessage = 2;
inline bool Message_InteractiveResponseMessage::_internal_has_nativeflowresponsemessage() const {
  return interactiveResponseMessage_case() == kNativeFlowResponseMessage;
}
inline bool Message_InteractiveResponseMessage::has_nativeflowresponsemessage() const {
  return _internal_has_nativeflowresponsemessage();
}
inline void Message_InteractiveResponseMessage::set_has_nativeflowresponsemessage() {
  _impl_._oneof_case_[0] = kNativeFlowResponseMessage;
}
inline void Message_InteractiveResponseMessage::clear_nativeflowresponsemessage() {
  if (_internal_has_nativeflowresponsemessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
    }
    clear_has_interactiveResponseMessage();
  }
}
inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::release_nativeflowresponsemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
  if (_internal_has_nativeflowresponsemessage()) {
    clear_has_interactiveResponseMessage();
    ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::_internal_nativeflowresponsemessage() const {
  return _internal_has_nativeflowresponsemessage()
      ? *_impl_.interactiveResponseMessage_.nativeflowresponsemessage_
      : reinterpret_cast< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage&>(::proto::_Message_InteractiveResponseMessage_NativeFlowResponseMessage_default_instance_);
}
inline const ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage& Message_InteractiveResponseMessage::nativeflowresponsemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
  return _internal_nativeflowresponsemessage();
}
inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::unsafe_arena_release_nativeflowresponsemessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
  if (_internal_has_nativeflowresponsemessage()) {
    clear_has_interactiveResponseMessage();
    ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* temp = _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_InteractiveResponseMessage::unsafe_arena_set_allocated_nativeflowresponsemessage(::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* nativeflowresponsemessage) {
  clear_interactiveResponseMessage();
  if (nativeflowresponsemessage) {
    set_has_nativeflowresponsemessage();
    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = nativeflowresponsemessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
}
inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::_internal_mutable_nativeflowresponsemessage() {
  if (!_internal_has_nativeflowresponsemessage()) {
    clear_interactiveResponseMessage();
    set_has_nativeflowresponsemessage();
    _impl_.interactiveResponseMessage_.nativeflowresponsemessage_ = CreateMaybeMessage< ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage >(GetArenaForAllocation());
  }
  return _impl_.interactiveResponseMessage_.nativeflowresponsemessage_;
}
inline ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* Message_InteractiveResponseMessage::mutable_nativeflowresponsemessage() {
  ::proto::Message_InteractiveResponseMessage_NativeFlowResponseMessage* _msg = _internal_mutable_nativeflowresponsemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.InteractiveResponseMessage.nativeFlowResponseMessage)
  return _msg;
}

inline bool Message_InteractiveResponseMessage::has_interactiveResponseMessage() const {
  return interactiveResponseMessage_case() != INTERACTIVERESPONSEMESSAGE_NOT_SET;
}
inline void Message_InteractiveResponseMessage::clear_has_interactiveResponseMessage() {
  _impl_._oneof_case_[0] = INTERACTIVERESPONSEMESSAGE_NOT_SET;
}
inline Message_InteractiveResponseMessage::InteractiveResponseMessageCase Message_InteractiveResponseMessage::interactiveResponseMessage_case() const {
  return Message_InteractiveResponseMessage::InteractiveResponseMessageCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_InvoiceMessage

// optional string note = 1;
inline bool Message_InvoiceMessage::_internal_has_note() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_note() const {
  return _internal_has_note();
}
inline void Message_InvoiceMessage::clear_note() {
  _impl_.note_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_InvoiceMessage::note() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.note)
  return _internal_note();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_note(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.note_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.note)
}
inline std::string* Message_InvoiceMessage::mutable_note() {
  std::string* _s = _internal_mutable_note();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.note)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_note() const {
  return _impl_.note_.Get();
}
inline void Message_InvoiceMessage::_internal_set_note(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.note_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_note() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.note_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_note() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.note)
  if (!_internal_has_note()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.note_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.note_.IsDefault()) {
    _impl_.note_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_note(std::string* note) {
  if (note != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.note_.SetAllocated(note, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.note_.IsDefault()) {
    _impl_.note_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.note)
}

// optional string token = 2;
inline bool Message_InvoiceMessage::_internal_has_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_token() const {
  return _internal_has_token();
}
inline void Message_InvoiceMessage::clear_token() {
  _impl_.token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_InvoiceMessage::token() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.token)
  return _internal_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.token)
}
inline std::string* Message_InvoiceMessage::mutable_token() {
  std::string* _s = _internal_mutable_token();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.token)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_token() const {
  return _impl_.token_.Get();
}
inline void Message_InvoiceMessage::_internal_set_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.token_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_token() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.token_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_token() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.token)
  if (!_internal_has_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_token(std::string* token) {
  if (token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.token)
}

// optional .proto.Message.InvoiceMessage.AttachmentType attachmentType = 3;
inline bool Message_InvoiceMessage::_internal_has_attachmenttype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmenttype() const {
  return _internal_has_attachmenttype();
}
inline void Message_InvoiceMessage::clear_attachmenttype() {
  _impl_.attachmenttype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::_internal_attachmenttype() const {
  return static_cast< ::proto::Message_InvoiceMessage_AttachmentType >(_impl_.attachmenttype_);
}
inline ::proto::Message_InvoiceMessage_AttachmentType Message_InvoiceMessage::attachmenttype() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentType)
  return _internal_attachmenttype();
}
inline void Message_InvoiceMessage::_internal_set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) {
  assert(::proto::Message_InvoiceMessage_AttachmentType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.attachmenttype_ = value;
}
inline void Message_InvoiceMessage::set_attachmenttype(::proto::Message_InvoiceMessage_AttachmentType value) {
  _internal_set_attachmenttype(value);
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentType)
}

// optional string attachmentMimetype = 4;
inline bool Message_InvoiceMessage::_internal_has_attachmentmimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentmimetype() const {
  return _internal_has_attachmentmimetype();
}
inline void Message_InvoiceMessage::clear_attachmentmimetype() {
  _impl_.attachmentmimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_InvoiceMessage::attachmentmimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMimetype)
  return _internal_attachmentmimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentmimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.attachmentmimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMimetype)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentmimetype() {
  std::string* _s = _internal_mutable_attachmentmimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMimetype)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentmimetype() const {
  return _impl_.attachmentmimetype_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentmimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.attachmentmimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmimetype() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.attachmentmimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentmimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMimetype)
  if (!_internal_has_attachmentmimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.attachmentmimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentmimetype_.IsDefault()) {
    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentmimetype(std::string* attachmentmimetype) {
  if (attachmentmimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.attachmentmimetype_.SetAllocated(attachmentmimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentmimetype_.IsDefault()) {
    _impl_.attachmentmimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMimetype)
}

// optional bytes attachmentMediaKey = 5;
inline bool Message_InvoiceMessage::_internal_has_attachmentmediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentmediakey() const {
  return _internal_has_attachmentmediakey();
}
inline void Message_InvoiceMessage::clear_attachmentmediakey() {
  _impl_.attachmentmediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_InvoiceMessage::attachmentmediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKey)
  return _internal_attachmentmediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentmediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.attachmentmediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKey)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentmediakey() {
  std::string* _s = _internal_mutable_attachmentmediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentMediaKey)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentmediakey() const {
  return _impl_.attachmentmediakey_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentmediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.attachmentmediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentmediakey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.attachmentmediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentmediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentMediaKey)
  if (!_internal_has_attachmentmediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.attachmentmediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentmediakey_.IsDefault()) {
    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentmediakey(std::string* attachmentmediakey) {
  if (attachmentmediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.attachmentmediakey_.SetAllocated(attachmentmediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentmediakey_.IsDefault()) {
    _impl_.attachmentmediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentMediaKey)
}

// optional int64 attachmentMediaKeyTimestamp = 6;
inline bool Message_InvoiceMessage::_internal_has_attachmentmediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentmediakeytimestamp() const {
  return _internal_has_attachmentmediakeytimestamp();
}
inline void Message_InvoiceMessage::clear_attachmentmediakeytimestamp() {
  _impl_.attachmentmediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t Message_InvoiceMessage::_internal_attachmentmediakeytimestamp() const {
  return _impl_.attachmentmediakeytimestamp_;
}
inline int64_t Message_InvoiceMessage::attachmentmediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp)
  return _internal_attachmentmediakeytimestamp();
}
inline void Message_InvoiceMessage::_internal_set_attachmentmediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.attachmentmediakeytimestamp_ = value;
}
inline void Message_InvoiceMessage::set_attachmentmediakeytimestamp(int64_t value) {
  _internal_set_attachmentmediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentMediaKeyTimestamp)
}

// optional bytes attachmentFileSha256 = 7;
inline bool Message_InvoiceMessage::_internal_has_attachmentfilesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentfilesha256() const {
  return _internal_has_attachmentfilesha256();
}
inline void Message_InvoiceMessage::clear_attachmentfilesha256() {
  _impl_.attachmentfilesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_InvoiceMessage::attachmentfilesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileSha256)
  return _internal_attachmentfilesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentfilesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.attachmentfilesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileSha256)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentfilesha256() {
  std::string* _s = _internal_mutable_attachmentfilesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileSha256)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentfilesha256() const {
  return _impl_.attachmentfilesha256_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentfilesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.attachmentfilesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfilesha256() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.attachmentfilesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentfilesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileSha256)
  if (!_internal_has_attachmentfilesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.attachmentfilesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentfilesha256_.IsDefault()) {
    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentfilesha256(std::string* attachmentfilesha256) {
  if (attachmentfilesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.attachmentfilesha256_.SetAllocated(attachmentfilesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentfilesha256_.IsDefault()) {
    _impl_.attachmentfilesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileSha256)
}

// optional bytes attachmentFileEncSha256 = 8;
inline bool Message_InvoiceMessage::_internal_has_attachmentfileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentfileencsha256() const {
  return _internal_has_attachmentfileencsha256();
}
inline void Message_InvoiceMessage::clear_attachmentfileencsha256() {
  _impl_.attachmentfileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_InvoiceMessage::attachmentfileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentFileEncSha256)
  return _internal_attachmentfileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentfileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.attachmentfileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentFileEncSha256)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentfileencsha256() {
  std::string* _s = _internal_mutable_attachmentfileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentFileEncSha256)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentfileencsha256() const {
  return _impl_.attachmentfileencsha256_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentfileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.attachmentfileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentfileencsha256() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.attachmentfileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentfileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentFileEncSha256)
  if (!_internal_has_attachmentfileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.attachmentfileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentfileencsha256_.IsDefault()) {
    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentfileencsha256(std::string* attachmentfileencsha256) {
  if (attachmentfileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.attachmentfileencsha256_.SetAllocated(attachmentfileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentfileencsha256_.IsDefault()) {
    _impl_.attachmentfileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentFileEncSha256)
}

// optional string attachmentDirectPath = 9;
inline bool Message_InvoiceMessage::_internal_has_attachmentdirectpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentdirectpath() const {
  return _internal_has_attachmentdirectpath();
}
inline void Message_InvoiceMessage::clear_attachmentdirectpath() {
  _impl_.attachmentdirectpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_InvoiceMessage::attachmentdirectpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentDirectPath)
  return _internal_attachmentdirectpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentdirectpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.attachmentdirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentDirectPath)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentdirectpath() {
  std::string* _s = _internal_mutable_attachmentdirectpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentDirectPath)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentdirectpath() const {
  return _impl_.attachmentdirectpath_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentdirectpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.attachmentdirectpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentdirectpath() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.attachmentdirectpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentdirectpath() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentDirectPath)
  if (!_internal_has_attachmentdirectpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.attachmentdirectpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentdirectpath_.IsDefault()) {
    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentdirectpath(std::string* attachmentdirectpath) {
  if (attachmentdirectpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.attachmentdirectpath_.SetAllocated(attachmentdirectpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentdirectpath_.IsDefault()) {
    _impl_.attachmentdirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentDirectPath)
}

// optional bytes attachmentJpegThumbnail = 10;
inline bool Message_InvoiceMessage::_internal_has_attachmentjpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_InvoiceMessage::has_attachmentjpegthumbnail() const {
  return _internal_has_attachmentjpegthumbnail();
}
inline void Message_InvoiceMessage::clear_attachmentjpegthumbnail() {
  _impl_.attachmentjpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_InvoiceMessage::attachmentjpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
  return _internal_attachmentjpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_InvoiceMessage::set_attachmentjpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.attachmentjpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
}
inline std::string* Message_InvoiceMessage::mutable_attachmentjpegthumbnail() {
  std::string* _s = _internal_mutable_attachmentjpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
  return _s;
}
inline const std::string& Message_InvoiceMessage::_internal_attachmentjpegthumbnail() const {
  return _impl_.attachmentjpegthumbnail_.Get();
}
inline void Message_InvoiceMessage::_internal_set_attachmentjpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.attachmentjpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::_internal_mutable_attachmentjpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.attachmentjpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_InvoiceMessage::release_attachmentjpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
  if (!_internal_has_attachmentjpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.attachmentjpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentjpegthumbnail_.IsDefault()) {
    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_InvoiceMessage::set_allocated_attachmentjpegthumbnail(std::string* attachmentjpegthumbnail) {
  if (attachmentjpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.attachmentjpegthumbnail_.SetAllocated(attachmentjpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.attachmentjpegthumbnail_.IsDefault()) {
    _impl_.attachmentjpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.InvoiceMessage.attachmentJpegThumbnail)
}

// -------------------------------------------------------------------

// Message_KeepInChatMessage

// optional .proto.MessageKey key = 1;
inline bool Message_KeepInChatMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Message_KeepInChatMessage::has_key() const {
  return _internal_has_key();
}
inline void Message_KeepInChatMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& Message_KeepInChatMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_KeepInChatMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.key)
  return _internal_key();
}
inline void Message_KeepInChatMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.KeepInChatMessage.key)
}
inline ::proto::MessageKey* Message_KeepInChatMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Message_KeepInChatMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Message.KeepInChatMessage.key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_KeepInChatMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Message_KeepInChatMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Message.KeepInChatMessage.key)
  return _msg;
}
inline void Message_KeepInChatMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.KeepInChatMessage.key)
}

// optional .proto.KeepType keepType = 2;
inline bool Message_KeepInChatMessage::_internal_has_keeptype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_KeepInChatMessage::has_keeptype() const {
  return _internal_has_keeptype();
}
inline void Message_KeepInChatMessage::clear_keeptype() {
  _impl_.keeptype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::KeepType Message_KeepInChatMessage::_internal_keeptype() const {
  return static_cast< ::proto::KeepType >(_impl_.keeptype_);
}
inline ::proto::KeepType Message_KeepInChatMessage::keeptype() const {
  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.keepType)
  return _internal_keeptype();
}
inline void Message_KeepInChatMessage::_internal_set_keeptype(::proto::KeepType value) {
  assert(::proto::KeepType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.keeptype_ = value;
}
inline void Message_KeepInChatMessage::set_keeptype(::proto::KeepType value) {
  _internal_set_keeptype(value);
  // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.keepType)
}

// optional int64 timestampMs = 3;
inline bool Message_KeepInChatMessage::_internal_has_timestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_KeepInChatMessage::has_timestampms() const {
  return _internal_has_timestampms();
}
inline void Message_KeepInChatMessage::clear_timestampms() {
  _impl_.timestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Message_KeepInChatMessage::_internal_timestampms() const {
  return _impl_.timestampms_;
}
inline int64_t Message_KeepInChatMessage::timestampms() const {
  // @@protoc_insertion_point(field_get:proto.Message.KeepInChatMessage.timestampMs)
  return _internal_timestampms();
}
inline void Message_KeepInChatMessage::_internal_set_timestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.timestampms_ = value;
}
inline void Message_KeepInChatMessage::set_timestampms(int64_t value) {
  _internal_set_timestampms(value);
  // @@protoc_insertion_point(field_set:proto.Message.KeepInChatMessage.timestampMs)
}

// -------------------------------------------------------------------

// Message_ListMessage_ProductListHeaderImage

// optional string productId = 1;
inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_productid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_ProductListHeaderImage::has_productid() const {
  return _internal_has_productid();
}
inline void Message_ListMessage_ProductListHeaderImage::clear_productid() {
  _impl_.productid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_ProductListHeaderImage::productid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.productId)
  return _internal_productid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_ProductListHeaderImage::set_productid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.productId)
}
inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_productid() {
  std::string* _s = _internal_mutable_productid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.productId)
  return _s;
}
inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_productid() const {
  return _impl_.productid_.Get();
}
inline void Message_ListMessage_ProductListHeaderImage::_internal_set_productid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.productid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_productid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.productid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListHeaderImage::release_productid() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.productId)
  if (!_internal_has_productid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.productid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_ProductListHeaderImage::set_allocated_productid(std::string* productid) {
  if (productid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.productId)
}

// optional bytes jpegThumbnail = 2;
inline bool Message_ListMessage_ProductListHeaderImage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ListMessage_ProductListHeaderImage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_ListMessage_ProductListHeaderImage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ListMessage_ProductListHeaderImage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_ProductListHeaderImage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
}
inline std::string* Message_ListMessage_ProductListHeaderImage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_ListMessage_ProductListHeaderImage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_ListMessage_ProductListHeaderImage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListHeaderImage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListHeaderImage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_ProductListHeaderImage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListHeaderImage.jpegThumbnail)
}

// -------------------------------------------------------------------

// Message_ListMessage_ProductListInfo

// repeated .proto.Message.ListMessage.ProductSection productSections = 1;
inline int Message_ListMessage_ProductListInfo::_internal_productsections_size() const {
  return _impl_.productsections_.size();
}
inline int Message_ListMessage_ProductListInfo::productsections_size() const {
  return _internal_productsections_size();
}
inline void Message_ListMessage_ProductListInfo::clear_productsections() {
  _impl_.productsections_.Clear();
}
inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::mutable_productsections(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.productSections)
  return _impl_.productsections_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >*
Message_ListMessage_ProductListInfo::mutable_productsections() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductListInfo.productSections)
  return &_impl_.productsections_;
}
inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::_internal_productsections(int index) const {
  return _impl_.productsections_.Get(index);
}
inline const ::proto::Message_ListMessage_ProductSection& Message_ListMessage_ProductListInfo::productsections(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.productSections)
  return _internal_productsections(index);
}
inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::_internal_add_productsections() {
  return _impl_.productsections_.Add();
}
inline ::proto::Message_ListMessage_ProductSection* Message_ListMessage_ProductListInfo::add_productsections() {
  ::proto::Message_ListMessage_ProductSection* _add = _internal_add_productsections();
  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductListInfo.productSections)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_ProductSection >&
Message_ListMessage_ProductListInfo::productsections() const {
  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductListInfo.productSections)
  return _impl_.productsections_;
}

// optional .proto.Message.ListMessage.ProductListHeaderImage headerImage = 2;
inline bool Message_ListMessage_ProductListInfo::_internal_has_headerimage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.headerimage_ != nullptr);
  return value;
}
inline bool Message_ListMessage_ProductListInfo::has_headerimage() const {
  return _internal_has_headerimage();
}
inline void Message_ListMessage_ProductListInfo::clear_headerimage() {
  if (_impl_.headerimage_ != nullptr) _impl_.headerimage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::_internal_headerimage() const {
  const ::proto::Message_ListMessage_ProductListHeaderImage* p = _impl_.headerimage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage_ProductListHeaderImage&>(
      ::proto::_Message_ListMessage_ProductListHeaderImage_default_instance_);
}
inline const ::proto::Message_ListMessage_ProductListHeaderImage& Message_ListMessage_ProductListInfo::headerimage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.headerImage)
  return _internal_headerimage();
}
inline void Message_ListMessage_ProductListInfo::unsafe_arena_set_allocated_headerimage(
    ::proto::Message_ListMessage_ProductListHeaderImage* headerimage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.headerimage_);
  }
  _impl_.headerimage_ = headerimage;
  if (headerimage) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage)
}
inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::release_headerimage() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_;
  _impl_.headerimage_ = 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 ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::unsafe_arena_release_headerimage() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.headerImage)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_ListMessage_ProductListHeaderImage* temp = _impl_.headerimage_;
  _impl_.headerimage_ = nullptr;
  return temp;
}
inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::_internal_mutable_headerimage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.headerimage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListHeaderImage>(GetArenaForAllocation());
    _impl_.headerimage_ = p;
  }
  return _impl_.headerimage_;
}
inline ::proto::Message_ListMessage_ProductListHeaderImage* Message_ListMessage_ProductListInfo::mutable_headerimage() {
  ::proto::Message_ListMessage_ProductListHeaderImage* _msg = _internal_mutable_headerimage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.headerImage)
  return _msg;
}
inline void Message_ListMessage_ProductListInfo::set_allocated_headerimage(::proto::Message_ListMessage_ProductListHeaderImage* headerimage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.headerimage_;
  }
  if (headerimage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(headerimage);
    if (message_arena != submessage_arena) {
      headerimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, headerimage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.headerimage_ = headerimage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.headerImage)
}

// optional string businessOwnerJid = 3;
inline bool Message_ListMessage_ProductListInfo::_internal_has_businessownerjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_ProductListInfo::has_businessownerjid() const {
  return _internal_has_businessownerjid();
}
inline void Message_ListMessage_ProductListInfo::clear_businessownerjid() {
  _impl_.businessownerjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_ProductListInfo::businessownerjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
  return _internal_businessownerjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_ProductListInfo::set_businessownerjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.businessownerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
}
inline std::string* Message_ListMessage_ProductListInfo::mutable_businessownerjid() {
  std::string* _s = _internal_mutable_businessownerjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
  return _s;
}
inline const std::string& Message_ListMessage_ProductListInfo::_internal_businessownerjid() const {
  return _impl_.businessownerjid_.Get();
}
inline void Message_ListMessage_ProductListInfo::_internal_set_businessownerjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.businessownerjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListInfo::_internal_mutable_businessownerjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.businessownerjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductListInfo::release_businessownerjid() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
  if (!_internal_has_businessownerjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.businessownerjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.businessownerjid_.IsDefault()) {
    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_ProductListInfo::set_allocated_businessownerjid(std::string* businessownerjid) {
  if (businessownerjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.businessownerjid_.IsDefault()) {
    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.ProductListInfo.businessOwnerJid)
}

// -------------------------------------------------------------------

// Message_ListMessage_ProductSection

// optional string title = 1;
inline bool Message_ListMessage_ProductSection::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_ProductSection::has_title() const {
  return _internal_has_title();
}
inline void Message_ListMessage_ProductSection::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_ProductSection::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_ProductSection::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.ProductSection.title)
}
inline std::string* Message_ListMessage_ProductSection::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.title)
  return _s;
}
inline const std::string& Message_ListMessage_ProductSection::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ListMessage_ProductSection::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductSection::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_ProductSection::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.ProductSection.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ListMessage_ProductSection::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ListMessage.ProductSection.title)
}

// repeated .proto.Message.ListMessage.Product products = 2;
inline int Message_ListMessage_ProductSection::_internal_products_size() const {
  return _impl_.products_.size();
}
inline int Message_ListMessage_ProductSection::products_size() const {
  return _internal_products_size();
}
inline void Message_ListMessage_ProductSection::clear_products() {
  _impl_.products_.Clear();
}
inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::mutable_products(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.ProductSection.products)
  return _impl_.products_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >*
Message_ListMessage_ProductSection::mutable_products() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.ProductSection.products)
  return &_impl_.products_;
}
inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::_internal_products(int index) const {
  return _impl_.products_.Get(index);
}
inline const ::proto::Message_ListMessage_Product& Message_ListMessage_ProductSection::products(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.ProductSection.products)
  return _internal_products(index);
}
inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::_internal_add_products() {
  return _impl_.products_.Add();
}
inline ::proto::Message_ListMessage_Product* Message_ListMessage_ProductSection::add_products() {
  ::proto::Message_ListMessage_Product* _add = _internal_add_products();
  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.ProductSection.products)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Product >&
Message_ListMessage_ProductSection::products() const {
  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.ProductSection.products)
  return _impl_.products_;
}

// -------------------------------------------------------------------

// Message_ListMessage_Product

// optional string productId = 1;
inline bool Message_ListMessage_Product::_internal_has_productid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_Product::has_productid() const {
  return _internal_has_productid();
}
inline void Message_ListMessage_Product::clear_productid() {
  _impl_.productid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_Product::productid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Product.productId)
  return _internal_productid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_Product::set_productid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Product.productId)
}
inline std::string* Message_ListMessage_Product::mutable_productid() {
  std::string* _s = _internal_mutable_productid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Product.productId)
  return _s;
}
inline const std::string& Message_ListMessage_Product::_internal_productid() const {
  return _impl_.productid_.Get();
}
inline void Message_ListMessage_Product::_internal_set_productid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.productid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Product::_internal_mutable_productid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.productid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Product::release_productid() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Product.productId)
  if (!_internal_has_productid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.productid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_Product::set_allocated_productid(std::string* productid) {
  if (productid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Product.productId)
}

// -------------------------------------------------------------------

// Message_ListMessage_Row

// optional string title = 1;
inline bool Message_ListMessage_Row::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_Row::has_title() const {
  return _internal_has_title();
}
inline void Message_ListMessage_Row::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_Row::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_Row::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.title)
}
inline std::string* Message_ListMessage_Row::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.title)
  return _s;
}
inline const std::string& Message_ListMessage_Row::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ListMessage_Row::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ListMessage_Row::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ListMessage.Row.title)
}

// optional string description = 2;
inline bool Message_ListMessage_Row::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ListMessage_Row::has_description() const {
  return _internal_has_description();
}
inline void Message_ListMessage_Row::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ListMessage_Row::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_Row::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.description)
}
inline std::string* Message_ListMessage_Row::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.description)
  return _s;
}
inline const std::string& Message_ListMessage_Row::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ListMessage_Row::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_Row::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.description)
}

// optional string rowId = 3;
inline bool Message_ListMessage_Row::_internal_has_rowid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ListMessage_Row::has_rowid() const {
  return _internal_has_rowid();
}
inline void Message_ListMessage_Row::clear_rowid() {
  _impl_.rowid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ListMessage_Row::rowid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Row.rowId)
  return _internal_rowid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_Row::set_rowid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.rowid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Row.rowId)
}
inline std::string* Message_ListMessage_Row::mutable_rowid() {
  std::string* _s = _internal_mutable_rowid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Row.rowId)
  return _s;
}
inline const std::string& Message_ListMessage_Row::_internal_rowid() const {
  return _impl_.rowid_.Get();
}
inline void Message_ListMessage_Row::_internal_set_rowid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.rowid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::_internal_mutable_rowid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.rowid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Row::release_rowid() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Row.rowId)
  if (!_internal_has_rowid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.rowid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rowid_.IsDefault()) {
    _impl_.rowid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage_Row::set_allocated_rowid(std::string* rowid) {
  if (rowid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.rowid_.SetAllocated(rowid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rowid_.IsDefault()) {
    _impl_.rowid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.Row.rowId)
}

// -------------------------------------------------------------------

// Message_ListMessage_Section

// optional string title = 1;
inline bool Message_ListMessage_Section::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage_Section::has_title() const {
  return _internal_has_title();
}
inline void Message_ListMessage_Section::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage_Section::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage_Section::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.Section.title)
}
inline std::string* Message_ListMessage_Section::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.title)
  return _s;
}
inline const std::string& Message_ListMessage_Section::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ListMessage_Section::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Section::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage_Section::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.Section.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ListMessage_Section::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ListMessage.Section.title)
}

// repeated .proto.Message.ListMessage.Row rows = 2;
inline int Message_ListMessage_Section::_internal_rows_size() const {
  return _impl_.rows_.size();
}
inline int Message_ListMessage_Section::rows_size() const {
  return _internal_rows_size();
}
inline void Message_ListMessage_Section::clear_rows() {
  _impl_.rows_.Clear();
}
inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::mutable_rows(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.Section.rows)
  return _impl_.rows_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >*
Message_ListMessage_Section::mutable_rows() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.Section.rows)
  return &_impl_.rows_;
}
inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::_internal_rows(int index) const {
  return _impl_.rows_.Get(index);
}
inline const ::proto::Message_ListMessage_Row& Message_ListMessage_Section::rows(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.Section.rows)
  return _internal_rows(index);
}
inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::_internal_add_rows() {
  return _impl_.rows_.Add();
}
inline ::proto::Message_ListMessage_Row* Message_ListMessage_Section::add_rows() {
  ::proto::Message_ListMessage_Row* _add = _internal_add_rows();
  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.Section.rows)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Row >&
Message_ListMessage_Section::rows() const {
  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.Section.rows)
  return _impl_.rows_;
}

// -------------------------------------------------------------------

// Message_ListMessage

// optional string title = 1;
inline bool Message_ListMessage::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListMessage::has_title() const {
  return _internal_has_title();
}
inline void Message_ListMessage::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListMessage::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.title)
}
inline std::string* Message_ListMessage::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.title)
  return _s;
}
inline const std::string& Message_ListMessage::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ListMessage::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ListMessage::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ListMessage.title)
}

// optional string description = 2;
inline bool Message_ListMessage::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ListMessage::has_description() const {
  return _internal_has_description();
}
inline void Message_ListMessage::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ListMessage::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.description)
}
inline std::string* Message_ListMessage::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.description)
  return _s;
}
inline const std::string& Message_ListMessage::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ListMessage::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.description)
}

// optional string buttonText = 3;
inline bool Message_ListMessage::_internal_has_buttontext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ListMessage::has_buttontext() const {
  return _internal_has_buttontext();
}
inline void Message_ListMessage::clear_buttontext() {
  _impl_.buttontext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ListMessage::buttontext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.buttonText)
  return _internal_buttontext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage::set_buttontext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.buttontext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.buttonText)
}
inline std::string* Message_ListMessage::mutable_buttontext() {
  std::string* _s = _internal_mutable_buttontext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.buttonText)
  return _s;
}
inline const std::string& Message_ListMessage::_internal_buttontext() const {
  return _impl_.buttontext_.Get();
}
inline void Message_ListMessage::_internal_set_buttontext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.buttontext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage::_internal_mutable_buttontext() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.buttontext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage::release_buttontext() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.buttonText)
  if (!_internal_has_buttontext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.buttontext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttontext_.IsDefault()) {
    _impl_.buttontext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage::set_allocated_buttontext(std::string* buttontext) {
  if (buttontext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.buttontext_.SetAllocated(buttontext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.buttontext_.IsDefault()) {
    _impl_.buttontext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.buttonText)
}

// optional .proto.Message.ListMessage.ListType listType = 4;
inline bool Message_ListMessage::_internal_has_listtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_ListMessage::has_listtype() const {
  return _internal_has_listtype();
}
inline void Message_ListMessage::clear_listtype() {
  _impl_.listtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::proto::Message_ListMessage_ListType Message_ListMessage::_internal_listtype() const {
  return static_cast< ::proto::Message_ListMessage_ListType >(_impl_.listtype_);
}
inline ::proto::Message_ListMessage_ListType Message_ListMessage::listtype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.listType)
  return _internal_listtype();
}
inline void Message_ListMessage::_internal_set_listtype(::proto::Message_ListMessage_ListType value) {
  assert(::proto::Message_ListMessage_ListType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.listtype_ = value;
}
inline void Message_ListMessage::set_listtype(::proto::Message_ListMessage_ListType value) {
  _internal_set_listtype(value);
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.listType)
}

// repeated .proto.Message.ListMessage.Section sections = 5;
inline int Message_ListMessage::_internal_sections_size() const {
  return _impl_.sections_.size();
}
inline int Message_ListMessage::sections_size() const {
  return _internal_sections_size();
}
inline void Message_ListMessage::clear_sections() {
  _impl_.sections_.Clear();
}
inline ::proto::Message_ListMessage_Section* Message_ListMessage::mutable_sections(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.sections)
  return _impl_.sections_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >*
Message_ListMessage::mutable_sections() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.ListMessage.sections)
  return &_impl_.sections_;
}
inline const ::proto::Message_ListMessage_Section& Message_ListMessage::_internal_sections(int index) const {
  return _impl_.sections_.Get(index);
}
inline const ::proto::Message_ListMessage_Section& Message_ListMessage::sections(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.sections)
  return _internal_sections(index);
}
inline ::proto::Message_ListMessage_Section* Message_ListMessage::_internal_add_sections() {
  return _impl_.sections_.Add();
}
inline ::proto::Message_ListMessage_Section* Message_ListMessage::add_sections() {
  ::proto::Message_ListMessage_Section* _add = _internal_add_sections();
  // @@protoc_insertion_point(field_add:proto.Message.ListMessage.sections)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_ListMessage_Section >&
Message_ListMessage::sections() const {
  // @@protoc_insertion_point(field_list:proto.Message.ListMessage.sections)
  return _impl_.sections_;
}

// optional .proto.Message.ListMessage.ProductListInfo productListInfo = 6;
inline bool Message_ListMessage::_internal_has_productlistinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.productlistinfo_ != nullptr);
  return value;
}
inline bool Message_ListMessage::has_productlistinfo() const {
  return _internal_has_productlistinfo();
}
inline void Message_ListMessage::clear_productlistinfo() {
  if (_impl_.productlistinfo_ != nullptr) _impl_.productlistinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::_internal_productlistinfo() const {
  const ::proto::Message_ListMessage_ProductListInfo* p = _impl_.productlistinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage_ProductListInfo&>(
      ::proto::_Message_ListMessage_ProductListInfo_default_instance_);
}
inline const ::proto::Message_ListMessage_ProductListInfo& Message_ListMessage::productlistinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.productListInfo)
  return _internal_productlistinfo();
}
inline void Message_ListMessage::unsafe_arena_set_allocated_productlistinfo(
    ::proto::Message_ListMessage_ProductListInfo* productlistinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productlistinfo_);
  }
  _impl_.productlistinfo_ = productlistinfo;
  if (productlistinfo) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.productListInfo)
}
inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::release_productlistinfo() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_;
  _impl_.productlistinfo_ = 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 ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::unsafe_arena_release_productlistinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.productListInfo)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_ListMessage_ProductListInfo* temp = _impl_.productlistinfo_;
  _impl_.productlistinfo_ = nullptr;
  return temp;
}
inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::_internal_mutable_productlistinfo() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.productlistinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ListMessage_ProductListInfo>(GetArenaForAllocation());
    _impl_.productlistinfo_ = p;
  }
  return _impl_.productlistinfo_;
}
inline ::proto::Message_ListMessage_ProductListInfo* Message_ListMessage::mutable_productlistinfo() {
  ::proto::Message_ListMessage_ProductListInfo* _msg = _internal_mutable_productlistinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.productListInfo)
  return _msg;
}
inline void Message_ListMessage::set_allocated_productlistinfo(::proto::Message_ListMessage_ProductListInfo* productlistinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.productlistinfo_;
  }
  if (productlistinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productlistinfo);
    if (message_arena != submessage_arena) {
      productlistinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, productlistinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.productlistinfo_ = productlistinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.productListInfo)
}

// optional string footerText = 7;
inline bool Message_ListMessage::_internal_has_footertext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ListMessage::has_footertext() const {
  return _internal_has_footertext();
}
inline void Message_ListMessage::clear_footertext() {
  _impl_.footertext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_ListMessage::footertext() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.footerText)
  return _internal_footertext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListMessage::set_footertext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.footertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListMessage.footerText)
}
inline std::string* Message_ListMessage::mutable_footertext() {
  std::string* _s = _internal_mutable_footertext();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.footerText)
  return _s;
}
inline const std::string& Message_ListMessage::_internal_footertext() const {
  return _impl_.footertext_.Get();
}
inline void Message_ListMessage::_internal_set_footertext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.footertext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListMessage::_internal_mutable_footertext() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.footertext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListMessage::release_footertext() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.footerText)
  if (!_internal_has_footertext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.footertext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footertext_.IsDefault()) {
    _impl_.footertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListMessage::set_allocated_footertext(std::string* footertext) {
  if (footertext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.footertext_.SetAllocated(footertext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footertext_.IsDefault()) {
    _impl_.footertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.footerText)
}

// optional .proto.ContextInfo contextInfo = 8;
inline bool Message_ListMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ListMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ListMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ContextInfo& Message_ListMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ListMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ListMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ListMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ListMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ListMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ListMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ListMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListMessage.contextInfo)
  return _msg;
}
inline void Message_ListMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_ListResponseMessage_SingleSelectReply

// optional string selectedRowId = 1;
inline bool Message_ListResponseMessage_SingleSelectReply::_internal_has_selectedrowid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListResponseMessage_SingleSelectReply::has_selectedrowid() const {
  return _internal_has_selectedrowid();
}
inline void Message_ListResponseMessage_SingleSelectReply::clear_selectedrowid() {
  _impl_.selectedrowid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListResponseMessage_SingleSelectReply::selectedrowid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
  return _internal_selectedrowid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListResponseMessage_SingleSelectReply::set_selectedrowid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.selectedrowid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
}
inline std::string* Message_ListResponseMessage_SingleSelectReply::mutable_selectedrowid() {
  std::string* _s = _internal_mutable_selectedrowid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
  return _s;
}
inline const std::string& Message_ListResponseMessage_SingleSelectReply::_internal_selectedrowid() const {
  return _impl_.selectedrowid_.Get();
}
inline void Message_ListResponseMessage_SingleSelectReply::_internal_set_selectedrowid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.selectedrowid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage_SingleSelectReply::_internal_mutable_selectedrowid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.selectedrowid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage_SingleSelectReply::release_selectedrowid() {
  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
  if (!_internal_has_selectedrowid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.selectedrowid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedrowid_.IsDefault()) {
    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListResponseMessage_SingleSelectReply::set_allocated_selectedrowid(std::string* selectedrowid) {
  if (selectedrowid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.selectedrowid_.SetAllocated(selectedrowid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedrowid_.IsDefault()) {
    _impl_.selectedrowid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.SingleSelectReply.selectedRowId)
}

// -------------------------------------------------------------------

// Message_ListResponseMessage

// optional string title = 1;
inline bool Message_ListResponseMessage::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ListResponseMessage::has_title() const {
  return _internal_has_title();
}
inline void Message_ListResponseMessage::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ListResponseMessage::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListResponseMessage::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.title)
}
inline std::string* Message_ListResponseMessage::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.title)
  return _s;
}
inline const std::string& Message_ListResponseMessage::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ListResponseMessage::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ListResponseMessage::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ListResponseMessage.title)
}

// optional .proto.Message.ListResponseMessage.ListType listType = 2;
inline bool Message_ListResponseMessage::_internal_has_listtype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_ListResponseMessage::has_listtype() const {
  return _internal_has_listtype();
}
inline void Message_ListResponseMessage::clear_listtype() {
  _impl_.listtype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::_internal_listtype() const {
  return static_cast< ::proto::Message_ListResponseMessage_ListType >(_impl_.listtype_);
}
inline ::proto::Message_ListResponseMessage_ListType Message_ListResponseMessage::listtype() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.listType)
  return _internal_listtype();
}
inline void Message_ListResponseMessage::_internal_set_listtype(::proto::Message_ListResponseMessage_ListType value) {
  assert(::proto::Message_ListResponseMessage_ListType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.listtype_ = value;
}
inline void Message_ListResponseMessage::set_listtype(::proto::Message_ListResponseMessage_ListType value) {
  _internal_set_listtype(value);
  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.listType)
}

// optional .proto.Message.ListResponseMessage.SingleSelectReply singleSelectReply = 3;
inline bool Message_ListResponseMessage::_internal_has_singleselectreply() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.singleselectreply_ != nullptr);
  return value;
}
inline bool Message_ListResponseMessage::has_singleselectreply() const {
  return _internal_has_singleselectreply();
}
inline void Message_ListResponseMessage::clear_singleselectreply() {
  if (_impl_.singleselectreply_ != nullptr) _impl_.singleselectreply_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::_internal_singleselectreply() const {
  const ::proto::Message_ListResponseMessage_SingleSelectReply* p = _impl_.singleselectreply_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListResponseMessage_SingleSelectReply&>(
      ::proto::_Message_ListResponseMessage_SingleSelectReply_default_instance_);
}
inline const ::proto::Message_ListResponseMessage_SingleSelectReply& Message_ListResponseMessage::singleselectreply() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.singleSelectReply)
  return _internal_singleselectreply();
}
inline void Message_ListResponseMessage::unsafe_arena_set_allocated_singleselectreply(
    ::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.singleselectreply_);
  }
  _impl_.singleselectreply_ = singleselectreply;
  if (singleselectreply) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.singleSelectReply)
}
inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::release_singleselectreply() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_;
  _impl_.singleselectreply_ = 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 ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::unsafe_arena_release_singleselectreply() {
  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.singleSelectReply)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ListResponseMessage_SingleSelectReply* temp = _impl_.singleselectreply_;
  _impl_.singleselectreply_ = nullptr;
  return temp;
}
inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::_internal_mutable_singleselectreply() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.singleselectreply_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage_SingleSelectReply>(GetArenaForAllocation());
    _impl_.singleselectreply_ = p;
  }
  return _impl_.singleselectreply_;
}
inline ::proto::Message_ListResponseMessage_SingleSelectReply* Message_ListResponseMessage::mutable_singleselectreply() {
  ::proto::Message_ListResponseMessage_SingleSelectReply* _msg = _internal_mutable_singleselectreply();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.singleSelectReply)
  return _msg;
}
inline void Message_ListResponseMessage::set_allocated_singleselectreply(::proto::Message_ListResponseMessage_SingleSelectReply* singleselectreply) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.singleselectreply_;
  }
  if (singleselectreply) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(singleselectreply);
    if (message_arena != submessage_arena) {
      singleselectreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, singleselectreply, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.singleselectreply_ = singleselectreply;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.singleSelectReply)
}

// optional .proto.ContextInfo contextInfo = 4;
inline bool Message_ListResponseMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ListResponseMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ListResponseMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::ContextInfo& Message_ListResponseMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ListResponseMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ListResponseMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ListResponseMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ListResponseMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ListResponseMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ListResponseMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ListResponseMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.contextInfo)
  return _msg;
}
inline void Message_ListResponseMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.contextInfo)
}

// optional string description = 5;
inline bool Message_ListResponseMessage::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ListResponseMessage::has_description() const {
  return _internal_has_description();
}
inline void Message_ListResponseMessage::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ListResponseMessage::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ListResponseMessage.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ListResponseMessage::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ListResponseMessage.description)
}
inline std::string* Message_ListResponseMessage::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ListResponseMessage.description)
  return _s;
}
inline const std::string& Message_ListResponseMessage::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ListResponseMessage::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ListResponseMessage::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ListResponseMessage.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ListResponseMessage::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ListResponseMessage.description)
}

// -------------------------------------------------------------------

// Message_LiveLocationMessage

// optional double degreesLatitude = 1;
inline bool Message_LiveLocationMessage::_internal_has_degreeslatitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_degreeslatitude() const {
  return _internal_has_degreeslatitude();
}
inline void Message_LiveLocationMessage::clear_degreeslatitude() {
  _impl_.degreeslatitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline double Message_LiveLocationMessage::_internal_degreeslatitude() const {
  return _impl_.degreeslatitude_;
}
inline double Message_LiveLocationMessage::degreeslatitude() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLatitude)
  return _internal_degreeslatitude();
}
inline void Message_LiveLocationMessage::_internal_set_degreeslatitude(double value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.degreeslatitude_ = value;
}
inline void Message_LiveLocationMessage::set_degreeslatitude(double value) {
  _internal_set_degreeslatitude(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLatitude)
}

// optional double degreesLongitude = 2;
inline bool Message_LiveLocationMessage::_internal_has_degreeslongitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_degreeslongitude() const {
  return _internal_has_degreeslongitude();
}
inline void Message_LiveLocationMessage::clear_degreeslongitude() {
  _impl_.degreeslongitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline double Message_LiveLocationMessage::_internal_degreeslongitude() const {
  return _impl_.degreeslongitude_;
}
inline double Message_LiveLocationMessage::degreeslongitude() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesLongitude)
  return _internal_degreeslongitude();
}
inline void Message_LiveLocationMessage::_internal_set_degreeslongitude(double value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.degreeslongitude_ = value;
}
inline void Message_LiveLocationMessage::set_degreeslongitude(double value) {
  _internal_set_degreeslongitude(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesLongitude)
}

// optional uint32 accuracyInMeters = 3;
inline bool Message_LiveLocationMessage::_internal_has_accuracyinmeters() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_accuracyinmeters() const {
  return _internal_has_accuracyinmeters();
}
inline void Message_LiveLocationMessage::clear_accuracyinmeters() {
  _impl_.accuracyinmeters_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t Message_LiveLocationMessage::_internal_accuracyinmeters() const {
  return _impl_.accuracyinmeters_;
}
inline uint32_t Message_LiveLocationMessage::accuracyinmeters() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.accuracyInMeters)
  return _internal_accuracyinmeters();
}
inline void Message_LiveLocationMessage::_internal_set_accuracyinmeters(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.accuracyinmeters_ = value;
}
inline void Message_LiveLocationMessage::set_accuracyinmeters(uint32_t value) {
  _internal_set_accuracyinmeters(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.accuracyInMeters)
}

// optional float speedInMps = 4;
inline bool Message_LiveLocationMessage::_internal_has_speedinmps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_speedinmps() const {
  return _internal_has_speedinmps();
}
inline void Message_LiveLocationMessage::clear_speedinmps() {
  _impl_.speedinmps_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline float Message_LiveLocationMessage::_internal_speedinmps() const {
  return _impl_.speedinmps_;
}
inline float Message_LiveLocationMessage::speedinmps() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.speedInMps)
  return _internal_speedinmps();
}
inline void Message_LiveLocationMessage::_internal_set_speedinmps(float value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.speedinmps_ = value;
}
inline void Message_LiveLocationMessage::set_speedinmps(float value) {
  _internal_set_speedinmps(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.speedInMps)
}

// optional uint32 degreesClockwiseFromMagneticNorth = 5;
inline bool Message_LiveLocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_degreesclockwisefrommagneticnorth() const {
  return _internal_has_degreesclockwisefrommagneticnorth();
}
inline void Message_LiveLocationMessage::clear_degreesclockwisefrommagneticnorth() {
  _impl_.degreesclockwisefrommagneticnorth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t Message_LiveLocationMessage::_internal_degreesclockwisefrommagneticnorth() const {
  return _impl_.degreesclockwisefrommagneticnorth_;
}
inline uint32_t Message_LiveLocationMessage::degreesclockwisefrommagneticnorth() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth)
  return _internal_degreesclockwisefrommagneticnorth();
}
inline void Message_LiveLocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.degreesclockwisefrommagneticnorth_ = value;
}
inline void Message_LiveLocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) {
  _internal_set_degreesclockwisefrommagneticnorth(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.degreesClockwiseFromMagneticNorth)
}

// optional string caption = 6;
inline bool Message_LiveLocationMessage::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_caption() const {
  return _internal_has_caption();
}
inline void Message_LiveLocationMessage::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_LiveLocationMessage::caption() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LiveLocationMessage::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.caption)
}
inline std::string* Message_LiveLocationMessage::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.caption)
  return _s;
}
inline const std::string& Message_LiveLocationMessage::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void Message_LiveLocationMessage::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LiveLocationMessage::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LiveLocationMessage::release_caption() {
  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_LiveLocationMessage::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.LiveLocationMessage.caption)
}

// optional int64 sequenceNumber = 7;
inline bool Message_LiveLocationMessage::_internal_has_sequencenumber() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_sequencenumber() const {
  return _internal_has_sequencenumber();
}
inline void Message_LiveLocationMessage::clear_sequencenumber() {
  _impl_.sequencenumber_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int64_t Message_LiveLocationMessage::_internal_sequencenumber() const {
  return _impl_.sequencenumber_;
}
inline int64_t Message_LiveLocationMessage::sequencenumber() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.sequenceNumber)
  return _internal_sequencenumber();
}
inline void Message_LiveLocationMessage::_internal_set_sequencenumber(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.sequencenumber_ = value;
}
inline void Message_LiveLocationMessage::set_sequencenumber(int64_t value) {
  _internal_set_sequencenumber(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.sequenceNumber)
}

// optional uint32 timeOffset = 8;
inline bool Message_LiveLocationMessage::_internal_has_timeoffset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_timeoffset() const {
  return _internal_has_timeoffset();
}
inline void Message_LiveLocationMessage::clear_timeoffset() {
  _impl_.timeoffset_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t Message_LiveLocationMessage::_internal_timeoffset() const {
  return _impl_.timeoffset_;
}
inline uint32_t Message_LiveLocationMessage::timeoffset() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.timeOffset)
  return _internal_timeoffset();
}
inline void Message_LiveLocationMessage::_internal_set_timeoffset(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.timeoffset_ = value;
}
inline void Message_LiveLocationMessage::set_timeoffset(uint32_t value) {
  _internal_set_timeoffset(value);
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.timeOffset)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_LiveLocationMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_LiveLocationMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_LiveLocationMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_LiveLocationMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LiveLocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LiveLocationMessage.jpegThumbnail)
}
inline std::string* Message_LiveLocationMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_LiveLocationMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_LiveLocationMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LiveLocationMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LiveLocationMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_LiveLocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_LiveLocationMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_LiveLocationMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_LiveLocationMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ContextInfo& Message_LiveLocationMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_LiveLocationMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.LiveLocationMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_LiveLocationMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LiveLocationMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_LiveLocationMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_LiveLocationMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.LiveLocationMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_LiveLocationMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_LiveLocationMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.LiveLocationMessage.contextInfo)
  return _msg;
}
inline void Message_LiveLocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LiveLocationMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_LocationMessage

// optional double degreesLatitude = 1;
inline bool Message_LocationMessage::_internal_has_degreeslatitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_degreeslatitude() const {
  return _internal_has_degreeslatitude();
}
inline void Message_LocationMessage::clear_degreeslatitude() {
  _impl_.degreeslatitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline double Message_LocationMessage::_internal_degreeslatitude() const {
  return _impl_.degreeslatitude_;
}
inline double Message_LocationMessage::degreeslatitude() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLatitude)
  return _internal_degreeslatitude();
}
inline void Message_LocationMessage::_internal_set_degreeslatitude(double value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.degreeslatitude_ = value;
}
inline void Message_LocationMessage::set_degreeslatitude(double value) {
  _internal_set_degreeslatitude(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLatitude)
}

// optional double degreesLongitude = 2;
inline bool Message_LocationMessage::_internal_has_degreeslongitude() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_degreeslongitude() const {
  return _internal_has_degreeslongitude();
}
inline void Message_LocationMessage::clear_degreeslongitude() {
  _impl_.degreeslongitude_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline double Message_LocationMessage::_internal_degreeslongitude() const {
  return _impl_.degreeslongitude_;
}
inline double Message_LocationMessage::degreeslongitude() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesLongitude)
  return _internal_degreeslongitude();
}
inline void Message_LocationMessage::_internal_set_degreeslongitude(double value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.degreeslongitude_ = value;
}
inline void Message_LocationMessage::set_degreeslongitude(double value) {
  _internal_set_degreeslongitude(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesLongitude)
}

// optional string name = 3;
inline bool Message_LocationMessage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_name() const {
  return _internal_has_name();
}
inline void Message_LocationMessage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_LocationMessage::name() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LocationMessage::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.name)
}
inline std::string* Message_LocationMessage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.name)
  return _s;
}
inline const std::string& Message_LocationMessage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Message_LocationMessage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::release_name() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_LocationMessage::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.LocationMessage.name)
}

// optional string address = 4;
inline bool Message_LocationMessage::_internal_has_address() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_address() const {
  return _internal_has_address();
}
inline void Message_LocationMessage::clear_address() {
  _impl_.address_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_LocationMessage::address() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.address)
  return _internal_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LocationMessage::set_address(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.address)
}
inline std::string* Message_LocationMessage::mutable_address() {
  std::string* _s = _internal_mutable_address();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.address)
  return _s;
}
inline const std::string& Message_LocationMessage::_internal_address() const {
  return _impl_.address_.Get();
}
inline void Message_LocationMessage::_internal_set_address(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.address_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::_internal_mutable_address() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.address_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::release_address() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.address)
  if (!_internal_has_address()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.address_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_LocationMessage::set_allocated_address(std::string* address) {
  if (address != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.address_.SetAllocated(address, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.address_.IsDefault()) {
    _impl_.address_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.address)
}

// optional string url = 5;
inline bool Message_LocationMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_LocationMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_LocationMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LocationMessage::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.url)
}
inline std::string* Message_LocationMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.url)
  return _s;
}
inline const std::string& Message_LocationMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_LocationMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  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 Message_LocationMessage::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _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:proto.Message.LocationMessage.url)
}

// optional bool isLive = 6;
inline bool Message_LocationMessage::_internal_has_islive() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_islive() const {
  return _internal_has_islive();
}
inline void Message_LocationMessage::clear_islive() {
  _impl_.islive_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool Message_LocationMessage::_internal_islive() const {
  return _impl_.islive_;
}
inline bool Message_LocationMessage::islive() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.isLive)
  return _internal_islive();
}
inline void Message_LocationMessage::_internal_set_islive(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.islive_ = value;
}
inline void Message_LocationMessage::set_islive(bool value) {
  _internal_set_islive(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.isLive)
}

// optional uint32 accuracyInMeters = 7;
inline bool Message_LocationMessage::_internal_has_accuracyinmeters() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_accuracyinmeters() const {
  return _internal_has_accuracyinmeters();
}
inline void Message_LocationMessage::clear_accuracyinmeters() {
  _impl_.accuracyinmeters_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t Message_LocationMessage::_internal_accuracyinmeters() const {
  return _impl_.accuracyinmeters_;
}
inline uint32_t Message_LocationMessage::accuracyinmeters() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.accuracyInMeters)
  return _internal_accuracyinmeters();
}
inline void Message_LocationMessage::_internal_set_accuracyinmeters(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.accuracyinmeters_ = value;
}
inline void Message_LocationMessage::set_accuracyinmeters(uint32_t value) {
  _internal_set_accuracyinmeters(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.accuracyInMeters)
}

// optional float speedInMps = 8;
inline bool Message_LocationMessage::_internal_has_speedinmps() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_speedinmps() const {
  return _internal_has_speedinmps();
}
inline void Message_LocationMessage::clear_speedinmps() {
  _impl_.speedinmps_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline float Message_LocationMessage::_internal_speedinmps() const {
  return _impl_.speedinmps_;
}
inline float Message_LocationMessage::speedinmps() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.speedInMps)
  return _internal_speedinmps();
}
inline void Message_LocationMessage::_internal_set_speedinmps(float value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.speedinmps_ = value;
}
inline void Message_LocationMessage::set_speedinmps(float value) {
  _internal_set_speedinmps(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.speedInMps)
}

// optional uint32 degreesClockwiseFromMagneticNorth = 9;
inline bool Message_LocationMessage::_internal_has_degreesclockwisefrommagneticnorth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_degreesclockwisefrommagneticnorth() const {
  return _internal_has_degreesclockwisefrommagneticnorth();
}
inline void Message_LocationMessage::clear_degreesclockwisefrommagneticnorth() {
  _impl_.degreesclockwisefrommagneticnorth_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t Message_LocationMessage::_internal_degreesclockwisefrommagneticnorth() const {
  return _impl_.degreesclockwisefrommagneticnorth_;
}
inline uint32_t Message_LocationMessage::degreesclockwisefrommagneticnorth() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth)
  return _internal_degreesclockwisefrommagneticnorth();
}
inline void Message_LocationMessage::_internal_set_degreesclockwisefrommagneticnorth(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.degreesclockwisefrommagneticnorth_ = value;
}
inline void Message_LocationMessage::set_degreesclockwisefrommagneticnorth(uint32_t value) {
  _internal_set_degreesclockwisefrommagneticnorth(value);
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.degreesClockwiseFromMagneticNorth)
}

// optional string comment = 11;
inline bool Message_LocationMessage::_internal_has_comment() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_comment() const {
  return _internal_has_comment();
}
inline void Message_LocationMessage::clear_comment() {
  _impl_.comment_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_LocationMessage::comment() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.comment)
  return _internal_comment();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LocationMessage::set_comment(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.comment_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.comment)
}
inline std::string* Message_LocationMessage::mutable_comment() {
  std::string* _s = _internal_mutable_comment();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.comment)
  return _s;
}
inline const std::string& Message_LocationMessage::_internal_comment() const {
  return _impl_.comment_.Get();
}
inline void Message_LocationMessage::_internal_set_comment(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.comment_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::_internal_mutable_comment() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.comment_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::release_comment() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.comment)
  if (!_internal_has_comment()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.comment_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_LocationMessage::set_allocated_comment(std::string* comment) {
  if (comment != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.comment_.SetAllocated(comment, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.comment_.IsDefault()) {
    _impl_.comment_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.comment)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_LocationMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_LocationMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_LocationMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_LocationMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_LocationMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.LocationMessage.jpegThumbnail)
}
inline std::string* Message_LocationMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_LocationMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_LocationMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_LocationMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_LocationMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_LocationMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_LocationMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_LocationMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ContextInfo& Message_LocationMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_LocationMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.LocationMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_LocationMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.LocationMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_LocationMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_LocationMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.LocationMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_LocationMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_LocationMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.LocationMessage.contextInfo)
  return _msg;
}
inline void Message_LocationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.LocationMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_OrderMessage

// optional string orderId = 1;
inline bool Message_OrderMessage::_internal_has_orderid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_orderid() const {
  return _internal_has_orderid();
}
inline void Message_OrderMessage::clear_orderid() {
  _impl_.orderid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_OrderMessage::orderid() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderId)
  return _internal_orderid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_orderid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.orderid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderId)
}
inline std::string* Message_OrderMessage::mutable_orderid() {
  std::string* _s = _internal_mutable_orderid();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderId)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_orderid() const {
  return _impl_.orderid_.Get();
}
inline void Message_OrderMessage::_internal_set_orderid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.orderid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_orderid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.orderid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_orderid() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderId)
  if (!_internal_has_orderid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.orderid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.orderid_.IsDefault()) {
    _impl_.orderid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_orderid(std::string* orderid) {
  if (orderid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.orderid_.SetAllocated(orderid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.orderid_.IsDefault()) {
    _impl_.orderid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderId)
}

// optional bytes thumbnail = 2;
inline bool Message_OrderMessage::_internal_has_thumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_thumbnail() const {
  return _internal_has_thumbnail();
}
inline void Message_OrderMessage::clear_thumbnail() {
  _impl_.thumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_OrderMessage::thumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.thumbnail)
  return _internal_thumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_thumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.thumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.thumbnail)
}
inline std::string* Message_OrderMessage::mutable_thumbnail() {
  std::string* _s = _internal_mutable_thumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.thumbnail)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_thumbnail() const {
  return _impl_.thumbnail_.Get();
}
inline void Message_OrderMessage::_internal_set_thumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.thumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_thumbnail() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.thumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_thumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.thumbnail)
  if (!_internal_has_thumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 Message_OrderMessage::set_allocated_thumbnail(std::string* thumbnail) {
  if (thumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:proto.Message.OrderMessage.thumbnail)
}

// optional int32 itemCount = 3;
inline bool Message_OrderMessage::_internal_has_itemcount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_itemcount() const {
  return _internal_has_itemcount();
}
inline void Message_OrderMessage::clear_itemcount() {
  _impl_.itemcount_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int32_t Message_OrderMessage::_internal_itemcount() const {
  return _impl_.itemcount_;
}
inline int32_t Message_OrderMessage::itemcount() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.itemCount)
  return _internal_itemcount();
}
inline void Message_OrderMessage::_internal_set_itemcount(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.itemcount_ = value;
}
inline void Message_OrderMessage::set_itemcount(int32_t value) {
  _internal_set_itemcount(value);
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.itemCount)
}

// optional .proto.Message.OrderMessage.OrderStatus status = 4;
inline bool Message_OrderMessage::_internal_has_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_status() const {
  return _internal_has_status();
}
inline void Message_OrderMessage::clear_status() {
  _impl_.status_ = 1;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::_internal_status() const {
  return static_cast< ::proto::Message_OrderMessage_OrderStatus >(_impl_.status_);
}
inline ::proto::Message_OrderMessage_OrderStatus Message_OrderMessage::status() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.status)
  return _internal_status();
}
inline void Message_OrderMessage::_internal_set_status(::proto::Message_OrderMessage_OrderStatus value) {
  assert(::proto::Message_OrderMessage_OrderStatus_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.status_ = value;
}
inline void Message_OrderMessage::set_status(::proto::Message_OrderMessage_OrderStatus value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.status)
}

// optional .proto.Message.OrderMessage.OrderSurface surface = 5;
inline bool Message_OrderMessage::_internal_has_surface() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_surface() const {
  return _internal_has_surface();
}
inline void Message_OrderMessage::clear_surface() {
  _impl_.surface_ = 1;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::_internal_surface() const {
  return static_cast< ::proto::Message_OrderMessage_OrderSurface >(_impl_.surface_);
}
inline ::proto::Message_OrderMessage_OrderSurface Message_OrderMessage::surface() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.surface)
  return _internal_surface();
}
inline void Message_OrderMessage::_internal_set_surface(::proto::Message_OrderMessage_OrderSurface value) {
  assert(::proto::Message_OrderMessage_OrderSurface_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.surface_ = value;
}
inline void Message_OrderMessage::set_surface(::proto::Message_OrderMessage_OrderSurface value) {
  _internal_set_surface(value);
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.surface)
}

// optional string message = 6;
inline bool Message_OrderMessage::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_message() const {
  return _internal_has_message();
}
inline void Message_OrderMessage::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_OrderMessage::message() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.message)
}
inline std::string* Message_OrderMessage::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.message)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_message() const {
  return _impl_.message_.Get();
}
inline void Message_OrderMessage::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_message() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.message)
  if (!_internal_has_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.message)
}

// optional string orderTitle = 7;
inline bool Message_OrderMessage::_internal_has_ordertitle() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_ordertitle() const {
  return _internal_has_ordertitle();
}
inline void Message_OrderMessage::clear_ordertitle() {
  _impl_.ordertitle_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_OrderMessage::ordertitle() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.orderTitle)
  return _internal_ordertitle();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_ordertitle(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.ordertitle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.orderTitle)
}
inline std::string* Message_OrderMessage::mutable_ordertitle() {
  std::string* _s = _internal_mutable_ordertitle();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.orderTitle)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_ordertitle() const {
  return _impl_.ordertitle_.Get();
}
inline void Message_OrderMessage::_internal_set_ordertitle(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.ordertitle_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_ordertitle() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.ordertitle_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_ordertitle() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.orderTitle)
  if (!_internal_has_ordertitle()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.ordertitle_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ordertitle_.IsDefault()) {
    _impl_.ordertitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_ordertitle(std::string* ordertitle) {
  if (ordertitle != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.ordertitle_.SetAllocated(ordertitle, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ordertitle_.IsDefault()) {
    _impl_.ordertitle_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.orderTitle)
}

// optional string sellerJid = 8;
inline bool Message_OrderMessage::_internal_has_sellerjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_sellerjid() const {
  return _internal_has_sellerjid();
}
inline void Message_OrderMessage::clear_sellerjid() {
  _impl_.sellerjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_OrderMessage::sellerjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.sellerJid)
  return _internal_sellerjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_sellerjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.sellerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.sellerJid)
}
inline std::string* Message_OrderMessage::mutable_sellerjid() {
  std::string* _s = _internal_mutable_sellerjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.sellerJid)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_sellerjid() const {
  return _impl_.sellerjid_.Get();
}
inline void Message_OrderMessage::_internal_set_sellerjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.sellerjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_sellerjid() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.sellerjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_sellerjid() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.sellerJid)
  if (!_internal_has_sellerjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.sellerjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sellerjid_.IsDefault()) {
    _impl_.sellerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_sellerjid(std::string* sellerjid) {
  if (sellerjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.sellerjid_.SetAllocated(sellerjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sellerjid_.IsDefault()) {
    _impl_.sellerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.sellerJid)
}

// optional string token = 9;
inline bool Message_OrderMessage::_internal_has_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_token() const {
  return _internal_has_token();
}
inline void Message_OrderMessage::clear_token() {
  _impl_.token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_OrderMessage::token() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.token)
  return _internal_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.token_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.token)
}
inline std::string* Message_OrderMessage::mutable_token() {
  std::string* _s = _internal_mutable_token();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.token)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_token() const {
  return _impl_.token_.Get();
}
inline void Message_OrderMessage::_internal_set_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.token_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_token() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.token_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_token() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.token)
  if (!_internal_has_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_token(std::string* token) {
  if (token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.token_.SetAllocated(token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.token_.IsDefault()) {
    _impl_.token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.token)
}

// optional int64 totalAmount1000 = 10;
inline bool Message_OrderMessage::_internal_has_totalamount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_totalamount1000() const {
  return _internal_has_totalamount1000();
}
inline void Message_OrderMessage::clear_totalamount1000() {
  _impl_.totalamount1000_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t Message_OrderMessage::_internal_totalamount1000() const {
  return _impl_.totalamount1000_;
}
inline int64_t Message_OrderMessage::totalamount1000() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalAmount1000)
  return _internal_totalamount1000();
}
inline void Message_OrderMessage::_internal_set_totalamount1000(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.totalamount1000_ = value;
}
inline void Message_OrderMessage::set_totalamount1000(int64_t value) {
  _internal_set_totalamount1000(value);
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalAmount1000)
}

// optional string totalCurrencyCode = 11;
inline bool Message_OrderMessage::_internal_has_totalcurrencycode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_OrderMessage::has_totalcurrencycode() const {
  return _internal_has_totalcurrencycode();
}
inline void Message_OrderMessage::clear_totalcurrencycode() {
  _impl_.totalcurrencycode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_OrderMessage::totalcurrencycode() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.totalCurrencyCode)
  return _internal_totalcurrencycode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_OrderMessage::set_totalcurrencycode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.totalcurrencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.OrderMessage.totalCurrencyCode)
}
inline std::string* Message_OrderMessage::mutable_totalcurrencycode() {
  std::string* _s = _internal_mutable_totalcurrencycode();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.totalCurrencyCode)
  return _s;
}
inline const std::string& Message_OrderMessage::_internal_totalcurrencycode() const {
  return _impl_.totalcurrencycode_.Get();
}
inline void Message_OrderMessage::_internal_set_totalcurrencycode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.totalcurrencycode_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::_internal_mutable_totalcurrencycode() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.totalcurrencycode_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_OrderMessage::release_totalcurrencycode() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.totalCurrencyCode)
  if (!_internal_has_totalcurrencycode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.totalcurrencycode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.totalcurrencycode_.IsDefault()) {
    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_OrderMessage::set_allocated_totalcurrencycode(std::string* totalcurrencycode) {
  if (totalcurrencycode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.totalcurrencycode_.SetAllocated(totalcurrencycode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.totalcurrencycode_.IsDefault()) {
    _impl_.totalcurrencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.totalCurrencyCode)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_OrderMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_OrderMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_OrderMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::ContextInfo& Message_OrderMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_OrderMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.OrderMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_OrderMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.OrderMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_OrderMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_OrderMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.OrderMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_OrderMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_OrderMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.OrderMessage.contextInfo)
  return _msg;
}
inline void Message_OrderMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.OrderMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_PaymentInviteMessage

// optional .proto.Message.PaymentInviteMessage.ServiceType serviceType = 1;
inline bool Message_PaymentInviteMessage::_internal_has_servicetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_PaymentInviteMessage::has_servicetype() const {
  return _internal_has_servicetype();
}
inline void Message_PaymentInviteMessage::clear_servicetype() {
  _impl_.servicetype_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::_internal_servicetype() const {
  return static_cast< ::proto::Message_PaymentInviteMessage_ServiceType >(_impl_.servicetype_);
}
inline ::proto::Message_PaymentInviteMessage_ServiceType Message_PaymentInviteMessage::servicetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.serviceType)
  return _internal_servicetype();
}
inline void Message_PaymentInviteMessage::_internal_set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) {
  assert(::proto::Message_PaymentInviteMessage_ServiceType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.servicetype_ = value;
}
inline void Message_PaymentInviteMessage::set_servicetype(::proto::Message_PaymentInviteMessage_ServiceType value) {
  _internal_set_servicetype(value);
  // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.serviceType)
}

// optional int64 expiryTimestamp = 2;
inline bool Message_PaymentInviteMessage::_internal_has_expirytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_PaymentInviteMessage::has_expirytimestamp() const {
  return _internal_has_expirytimestamp();
}
inline void Message_PaymentInviteMessage::clear_expirytimestamp() {
  _impl_.expirytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t Message_PaymentInviteMessage::_internal_expirytimestamp() const {
  return _impl_.expirytimestamp_;
}
inline int64_t Message_PaymentInviteMessage::expirytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.PaymentInviteMessage.expiryTimestamp)
  return _internal_expirytimestamp();
}
inline void Message_PaymentInviteMessage::_internal_set_expirytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.expirytimestamp_ = value;
}
inline void Message_PaymentInviteMessage::set_expirytimestamp(int64_t value) {
  _internal_set_expirytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.PaymentInviteMessage.expiryTimestamp)
}

// -------------------------------------------------------------------

// Message_PollCreationMessage_Option

// optional string optionName = 1;
inline bool Message_PollCreationMessage_Option::_internal_has_optionname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_PollCreationMessage_Option::has_optionname() const {
  return _internal_has_optionname();
}
inline void Message_PollCreationMessage_Option::clear_optionname() {
  _impl_.optionname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_PollCreationMessage_Option::optionname() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.Option.optionName)
  return _internal_optionname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_PollCreationMessage_Option::set_optionname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.optionname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.Option.optionName)
}
inline std::string* Message_PollCreationMessage_Option::mutable_optionname() {
  std::string* _s = _internal_mutable_optionname();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.Option.optionName)
  return _s;
}
inline const std::string& Message_PollCreationMessage_Option::_internal_optionname() const {
  return _impl_.optionname_.Get();
}
inline void Message_PollCreationMessage_Option::_internal_set_optionname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.optionname_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage_Option::_internal_mutable_optionname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.optionname_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage_Option::release_optionname() {
  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.Option.optionName)
  if (!_internal_has_optionname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.optionname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.optionname_.IsDefault()) {
    _impl_.optionname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_PollCreationMessage_Option::set_allocated_optionname(std::string* optionname) {
  if (optionname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.optionname_.SetAllocated(optionname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.optionname_.IsDefault()) {
    _impl_.optionname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.Option.optionName)
}

// -------------------------------------------------------------------

// Message_PollCreationMessage

// optional bytes encKey = 1;
inline bool Message_PollCreationMessage::_internal_has_enckey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_PollCreationMessage::has_enckey() const {
  return _internal_has_enckey();
}
inline void Message_PollCreationMessage::clear_enckey() {
  _impl_.enckey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_PollCreationMessage::enckey() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.encKey)
  return _internal_enckey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_PollCreationMessage::set_enckey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.enckey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.encKey)
}
inline std::string* Message_PollCreationMessage::mutable_enckey() {
  std::string* _s = _internal_mutable_enckey();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.encKey)
  return _s;
}
inline const std::string& Message_PollCreationMessage::_internal_enckey() const {
  return _impl_.enckey_.Get();
}
inline void Message_PollCreationMessage::_internal_set_enckey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.enckey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage::_internal_mutable_enckey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.enckey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage::release_enckey() {
  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.encKey)
  if (!_internal_has_enckey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.enckey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enckey_.IsDefault()) {
    _impl_.enckey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_PollCreationMessage::set_allocated_enckey(std::string* enckey) {
  if (enckey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.enckey_.SetAllocated(enckey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enckey_.IsDefault()) {
    _impl_.enckey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.encKey)
}

// optional string name = 2;
inline bool Message_PollCreationMessage::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_PollCreationMessage::has_name() const {
  return _internal_has_name();
}
inline void Message_PollCreationMessage::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_PollCreationMessage::name() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_PollCreationMessage::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:proto.Message.PollCreationMessage.name)
}
inline std::string* Message_PollCreationMessage::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.name)
  return _s;
}
inline const std::string& Message_PollCreationMessage::_internal_name() const {
  return _impl_.name_.Get();
}
inline void Message_PollCreationMessage::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_PollCreationMessage::release_name() {
  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.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 Message_PollCreationMessage::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:proto.Message.PollCreationMessage.name)
}

// repeated .proto.Message.PollCreationMessage.Option options = 3;
inline int Message_PollCreationMessage::_internal_options_size() const {
  return _impl_.options_.size();
}
inline int Message_PollCreationMessage::options_size() const {
  return _internal_options_size();
}
inline void Message_PollCreationMessage::clear_options() {
  _impl_.options_.Clear();
}
inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::mutable_options(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.options)
  return _impl_.options_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >*
Message_PollCreationMessage::mutable_options() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.PollCreationMessage.options)
  return &_impl_.options_;
}
inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::_internal_options(int index) const {
  return _impl_.options_.Get(index);
}
inline const ::proto::Message_PollCreationMessage_Option& Message_PollCreationMessage::options(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.options)
  return _internal_options(index);
}
inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::_internal_add_options() {
  return _impl_.options_.Add();
}
inline ::proto::Message_PollCreationMessage_Option* Message_PollCreationMessage::add_options() {
  ::proto::Message_PollCreationMessage_Option* _add = _internal_add_options();
  // @@protoc_insertion_point(field_add:proto.Message.PollCreationMessage.options)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_PollCreationMessage_Option >&
Message_PollCreationMessage::options() const {
  // @@protoc_insertion_point(field_list:proto.Message.PollCreationMessage.options)
  return _impl_.options_;
}

// optional uint32 selectableOptionsCount = 4;
inline bool Message_PollCreationMessage::_internal_has_selectableoptionscount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_PollCreationMessage::has_selectableoptionscount() const {
  return _internal_has_selectableoptionscount();
}
inline void Message_PollCreationMessage::clear_selectableoptionscount() {
  _impl_.selectableoptionscount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Message_PollCreationMessage::_internal_selectableoptionscount() const {
  return _impl_.selectableoptionscount_;
}
inline uint32_t Message_PollCreationMessage::selectableoptionscount() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.selectableOptionsCount)
  return _internal_selectableoptionscount();
}
inline void Message_PollCreationMessage::_internal_set_selectableoptionscount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.selectableoptionscount_ = value;
}
inline void Message_PollCreationMessage::set_selectableoptionscount(uint32_t value) {
  _internal_set_selectableoptionscount(value);
  // @@protoc_insertion_point(field_set:proto.Message.PollCreationMessage.selectableOptionsCount)
}

// optional .proto.ContextInfo contextInfo = 5;
inline bool Message_PollCreationMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_PollCreationMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_PollCreationMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ContextInfo& Message_PollCreationMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_PollCreationMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollCreationMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_PollCreationMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollCreationMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_PollCreationMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_PollCreationMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.PollCreationMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_PollCreationMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_PollCreationMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollCreationMessage.contextInfo)
  return _msg;
}
inline void Message_PollCreationMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollCreationMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_PollEncValue

// optional bytes encPayload = 1;
inline bool Message_PollEncValue::_internal_has_encpayload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_PollEncValue::has_encpayload() const {
  return _internal_has_encpayload();
}
inline void Message_PollEncValue::clear_encpayload() {
  _impl_.encpayload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_PollEncValue::encpayload() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encPayload)
  return _internal_encpayload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.encpayload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encPayload)
}
inline std::string* Message_PollEncValue::mutable_encpayload() {
  std::string* _s = _internal_mutable_encpayload();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encPayload)
  return _s;
}
inline const std::string& Message_PollEncValue::_internal_encpayload() const {
  return _impl_.encpayload_.Get();
}
inline void Message_PollEncValue::_internal_set_encpayload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.encpayload_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_PollEncValue::_internal_mutable_encpayload() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.encpayload_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_PollEncValue::release_encpayload() {
  // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encPayload)
  if (!_internal_has_encpayload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.encpayload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encpayload_.IsDefault()) {
    _impl_.encpayload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_PollEncValue::set_allocated_encpayload(std::string* encpayload) {
  if (encpayload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encpayload_.IsDefault()) {
    _impl_.encpayload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encPayload)
}

// optional bytes encIv = 2;
inline bool Message_PollEncValue::_internal_has_enciv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_PollEncValue::has_enciv() const {
  return _internal_has_enciv();
}
inline void Message_PollEncValue::clear_enciv() {
  _impl_.enciv_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_PollEncValue::enciv() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollEncValue.encIv)
  return _internal_enciv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.enciv_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.PollEncValue.encIv)
}
inline std::string* Message_PollEncValue::mutable_enciv() {
  std::string* _s = _internal_mutable_enciv();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollEncValue.encIv)
  return _s;
}
inline const std::string& Message_PollEncValue::_internal_enciv() const {
  return _impl_.enciv_.Get();
}
inline void Message_PollEncValue::_internal_set_enciv(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.enciv_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_PollEncValue::_internal_mutable_enciv() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.enciv_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_PollEncValue::release_enciv() {
  // @@protoc_insertion_point(field_release:proto.Message.PollEncValue.encIv)
  if (!_internal_has_enciv()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.enciv_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enciv_.IsDefault()) {
    _impl_.enciv_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_PollEncValue::set_allocated_enciv(std::string* enciv) {
  if (enciv != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enciv_.IsDefault()) {
    _impl_.enciv_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollEncValue.encIv)
}

// -------------------------------------------------------------------

// Message_PollUpdateMessageMetadata

// -------------------------------------------------------------------

// Message_PollUpdateMessage

// optional .proto.MessageKey pollCreationMessageKey = 1;
inline bool Message_PollUpdateMessage::_internal_has_pollcreationmessagekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pollcreationmessagekey_ != nullptr);
  return value;
}
inline bool Message_PollUpdateMessage::has_pollcreationmessagekey() const {
  return _internal_has_pollcreationmessagekey();
}
inline void Message_PollUpdateMessage::clear_pollcreationmessagekey() {
  if (_impl_.pollcreationmessagekey_ != nullptr) _impl_.pollcreationmessagekey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& Message_PollUpdateMessage::_internal_pollcreationmessagekey() const {
  const ::proto::MessageKey* p = _impl_.pollcreationmessagekey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_PollUpdateMessage::pollcreationmessagekey() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.pollCreationMessageKey)
  return _internal_pollcreationmessagekey();
}
inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_pollcreationmessagekey(
    ::proto::MessageKey* pollcreationmessagekey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessagekey_);
  }
  _impl_.pollcreationmessagekey_ = pollcreationmessagekey;
  if (pollcreationmessagekey) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey)
}
inline ::proto::MessageKey* Message_PollUpdateMessage::release_pollcreationmessagekey() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_;
  _impl_.pollcreationmessagekey_ = 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 ::proto::MessageKey* Message_PollUpdateMessage::unsafe_arena_release_pollcreationmessagekey() {
  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.pollCreationMessageKey)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.pollcreationmessagekey_;
  _impl_.pollcreationmessagekey_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_PollUpdateMessage::_internal_mutable_pollcreationmessagekey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pollcreationmessagekey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.pollcreationmessagekey_ = p;
  }
  return _impl_.pollcreationmessagekey_;
}
inline ::proto::MessageKey* Message_PollUpdateMessage::mutable_pollcreationmessagekey() {
  ::proto::MessageKey* _msg = _internal_mutable_pollcreationmessagekey();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.pollCreationMessageKey)
  return _msg;
}
inline void Message_PollUpdateMessage::set_allocated_pollcreationmessagekey(::proto::MessageKey* pollcreationmessagekey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pollcreationmessagekey_;
  }
  if (pollcreationmessagekey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessagekey);
    if (message_arena != submessage_arena) {
      pollcreationmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pollcreationmessagekey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pollcreationmessagekey_ = pollcreationmessagekey;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.pollCreationMessageKey)
}

// optional .proto.Message.PollEncValue vote = 2;
inline bool Message_PollUpdateMessage::_internal_has_vote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr);
  return value;
}
inline bool Message_PollUpdateMessage::has_vote() const {
  return _internal_has_vote();
}
inline void Message_PollUpdateMessage::clear_vote() {
  if (_impl_.vote_ != nullptr) _impl_.vote_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::_internal_vote() const {
  const ::proto::Message_PollEncValue* p = _impl_.vote_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollEncValue&>(
      ::proto::_Message_PollEncValue_default_instance_);
}
inline const ::proto::Message_PollEncValue& Message_PollUpdateMessage::vote() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.vote)
  return _internal_vote();
}
inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_vote(
    ::proto::Message_PollEncValue* vote) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_);
  }
  _impl_.vote_ = vote;
  if (vote) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.vote)
}
inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::release_vote() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_PollEncValue* temp = _impl_.vote_;
  _impl_.vote_ = 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 ::proto::Message_PollEncValue* Message_PollUpdateMessage::unsafe_arena_release_vote() {
  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.vote)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_PollEncValue* temp = _impl_.vote_;
  _impl_.vote_ = nullptr;
  return temp;
}
inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::_internal_mutable_vote() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.vote_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PollEncValue>(GetArenaForAllocation());
    _impl_.vote_ = p;
  }
  return _impl_.vote_;
}
inline ::proto::Message_PollEncValue* Message_PollUpdateMessage::mutable_vote() {
  ::proto::Message_PollEncValue* _msg = _internal_mutable_vote();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.vote)
  return _msg;
}
inline void Message_PollUpdateMessage::set_allocated_vote(::proto::Message_PollEncValue* vote) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.vote_;
  }
  if (vote) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote);
    if (message_arena != submessage_arena) {
      vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vote, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.vote_ = vote;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.vote)
}

// optional .proto.Message.PollUpdateMessageMetadata metadata = 3;
inline bool Message_PollUpdateMessage::_internal_has_metadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.metadata_ != nullptr);
  return value;
}
inline bool Message_PollUpdateMessage::has_metadata() const {
  return _internal_has_metadata();
}
inline void Message_PollUpdateMessage::clear_metadata() {
  if (_impl_.metadata_ != nullptr) _impl_.metadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::_internal_metadata() const {
  const ::proto::Message_PollUpdateMessageMetadata* p = _impl_.metadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollUpdateMessageMetadata&>(
      ::proto::_Message_PollUpdateMessageMetadata_default_instance_);
}
inline const ::proto::Message_PollUpdateMessageMetadata& Message_PollUpdateMessage::metadata() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.metadata)
  return _internal_metadata();
}
inline void Message_PollUpdateMessage::unsafe_arena_set_allocated_metadata(
    ::proto::Message_PollUpdateMessageMetadata* metadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
  }
  _impl_.metadata_ = metadata;
  if (metadata) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.PollUpdateMessage.metadata)
}
inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::release_metadata() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = 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 ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::unsafe_arena_release_metadata() {
  // @@protoc_insertion_point(field_release:proto.Message.PollUpdateMessage.metadata)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_PollUpdateMessageMetadata* temp = _impl_.metadata_;
  _impl_.metadata_ = nullptr;
  return temp;
}
inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::_internal_mutable_metadata() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessageMetadata>(GetArenaForAllocation());
    _impl_.metadata_ = p;
  }
  return _impl_.metadata_;
}
inline ::proto::Message_PollUpdateMessageMetadata* Message_PollUpdateMessage::mutable_metadata() {
  ::proto::Message_PollUpdateMessageMetadata* _msg = _internal_mutable_metadata();
  // @@protoc_insertion_point(field_mutable:proto.Message.PollUpdateMessage.metadata)
  return _msg;
}
inline void Message_PollUpdateMessage::set_allocated_metadata(::proto::Message_PollUpdateMessageMetadata* metadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.metadata_;
  }
  if (metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(metadata);
    if (message_arena != submessage_arena) {
      metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, metadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.metadata_ = metadata;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.PollUpdateMessage.metadata)
}

// optional int64 senderTimestampMs = 4;
inline bool Message_PollUpdateMessage::_internal_has_sendertimestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_PollUpdateMessage::has_sendertimestampms() const {
  return _internal_has_sendertimestampms();
}
inline void Message_PollUpdateMessage::clear_sendertimestampms() {
  _impl_.sendertimestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t Message_PollUpdateMessage::_internal_sendertimestampms() const {
  return _impl_.sendertimestampms_;
}
inline int64_t Message_PollUpdateMessage::sendertimestampms() const {
  // @@protoc_insertion_point(field_get:proto.Message.PollUpdateMessage.senderTimestampMs)
  return _internal_sendertimestampms();
}
inline void Message_PollUpdateMessage::_internal_set_sendertimestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.sendertimestampms_ = value;
}
inline void Message_PollUpdateMessage::set_sendertimestampms(int64_t value) {
  _internal_set_sendertimestampms(value);
  // @@protoc_insertion_point(field_set:proto.Message.PollUpdateMessage.senderTimestampMs)
}

// -------------------------------------------------------------------

// Message_PollVoteMessage

// repeated bytes selectedOptions = 1;
inline int Message_PollVoteMessage::_internal_selectedoptions_size() const {
  return _impl_.selectedoptions_.size();
}
inline int Message_PollVoteMessage::selectedoptions_size() const {
  return _internal_selectedoptions_size();
}
inline void Message_PollVoteMessage::clear_selectedoptions() {
  _impl_.selectedoptions_.Clear();
}
inline std::string* Message_PollVoteMessage::add_selectedoptions() {
  std::string* _s = _internal_add_selectedoptions();
  // @@protoc_insertion_point(field_add_mutable:proto.Message.PollVoteMessage.selectedOptions)
  return _s;
}
inline const std::string& Message_PollVoteMessage::_internal_selectedoptions(int index) const {
  return _impl_.selectedoptions_.Get(index);
}
inline const std::string& Message_PollVoteMessage::selectedoptions(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.PollVoteMessage.selectedOptions)
  return _internal_selectedoptions(index);
}
inline std::string* Message_PollVoteMessage::mutable_selectedoptions(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.PollVoteMessage.selectedOptions)
  return _impl_.selectedoptions_.Mutable(index);
}
inline void Message_PollVoteMessage::set_selectedoptions(int index, const std::string& value) {
  _impl_.selectedoptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::set_selectedoptions(int index, std::string&& value) {
  _impl_.selectedoptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::set_selectedoptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.selectedoptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::set_selectedoptions(int index, const void* value, size_t size) {
  _impl_.selectedoptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.Message.PollVoteMessage.selectedOptions)
}
inline std::string* Message_PollVoteMessage::_internal_add_selectedoptions() {
  return _impl_.selectedoptions_.Add();
}
inline void Message_PollVoteMessage::add_selectedoptions(const std::string& value) {
  _impl_.selectedoptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::add_selectedoptions(std::string&& value) {
  _impl_.selectedoptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::add_selectedoptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.selectedoptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.Message.PollVoteMessage.selectedOptions)
}
inline void Message_PollVoteMessage::add_selectedoptions(const void* value, size_t size) {
  _impl_.selectedoptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.Message.PollVoteMessage.selectedOptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Message_PollVoteMessage::selectedoptions() const {
  // @@protoc_insertion_point(field_list:proto.Message.PollVoteMessage.selectedOptions)
  return _impl_.selectedoptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Message_PollVoteMessage::mutable_selectedoptions() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.PollVoteMessage.selectedOptions)
  return &_impl_.selectedoptions_;
}

// -------------------------------------------------------------------

// Message_ProductMessage_CatalogSnapshot

// optional .proto.Message.ImageMessage catalogImage = 1;
inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_catalogimage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.catalogimage_ != nullptr);
  return value;
}
inline bool Message_ProductMessage_CatalogSnapshot::has_catalogimage() const {
  return _internal_has_catalogimage();
}
inline void Message_ProductMessage_CatalogSnapshot::clear_catalogimage() {
  if (_impl_.catalogimage_ != nullptr) _impl_.catalogimage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::_internal_catalogimage() const {
  const ::proto::Message_ImageMessage* p = _impl_.catalogimage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
      ::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_ProductMessage_CatalogSnapshot::catalogimage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
  return _internal_catalogimage();
}
inline void Message_ProductMessage_CatalogSnapshot::unsafe_arena_set_allocated_catalogimage(
    ::proto::Message_ImageMessage* catalogimage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalogimage_);
  }
  _impl_.catalogimage_ = catalogimage;
  if (catalogimage) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::release_catalogimage() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ImageMessage* temp = _impl_.catalogimage_;
  _impl_.catalogimage_ = 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 ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::unsafe_arena_release_catalogimage() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ImageMessage* temp = _impl_.catalogimage_;
  _impl_.catalogimage_ = nullptr;
  return temp;
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::_internal_mutable_catalogimage() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.catalogimage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
    _impl_.catalogimage_ = p;
  }
  return _impl_.catalogimage_;
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_CatalogSnapshot::mutable_catalogimage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_catalogimage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
  return _msg;
}
inline void Message_ProductMessage_CatalogSnapshot::set_allocated_catalogimage(::proto::Message_ImageMessage* catalogimage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.catalogimage_;
  }
  if (catalogimage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalogimage);
    if (message_arena != submessage_arena) {
      catalogimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, catalogimage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.catalogimage_ = catalogimage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.catalogImage)
}

// optional string title = 2;
inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ProductMessage_CatalogSnapshot::has_title() const {
  return _internal_has_title();
}
inline void Message_ProductMessage_CatalogSnapshot::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ProductMessage_CatalogSnapshot::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_CatalogSnapshot::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.title)
}
inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.title)
  return _s;
}
inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ProductMessage_CatalogSnapshot::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_CatalogSnapshot::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ProductMessage_CatalogSnapshot::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ProductMessage.CatalogSnapshot.title)
}

// optional string description = 3;
inline bool Message_ProductMessage_CatalogSnapshot::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ProductMessage_CatalogSnapshot::has_description() const {
  return _internal_has_description();
}
inline void Message_ProductMessage_CatalogSnapshot::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ProductMessage_CatalogSnapshot::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.CatalogSnapshot.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_CatalogSnapshot::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.CatalogSnapshot.description)
}
inline std::string* Message_ProductMessage_CatalogSnapshot::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.CatalogSnapshot.description)
  return _s;
}
inline const std::string& Message_ProductMessage_CatalogSnapshot::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ProductMessage_CatalogSnapshot::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_CatalogSnapshot::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_CatalogSnapshot::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.CatalogSnapshot.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_CatalogSnapshot::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.CatalogSnapshot.description)
}

// -------------------------------------------------------------------

// Message_ProductMessage_ProductSnapshot

// optional .proto.Message.ImageMessage productImage = 1;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.productimage_ != nullptr);
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_productimage() const {
  return _internal_has_productimage();
}
inline void Message_ProductMessage_ProductSnapshot::clear_productimage() {
  if (_impl_.productimage_ != nullptr) _impl_.productimage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::_internal_productimage() const {
  const ::proto::Message_ImageMessage* p = _impl_.productimage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
      ::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_ProductMessage_ProductSnapshot::productimage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImage)
  return _internal_productimage();
}
inline void Message_ProductMessage_ProductSnapshot::unsafe_arena_set_allocated_productimage(
    ::proto::Message_ImageMessage* productimage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productimage_);
  }
  _impl_.productimage_ = productimage;
  if (productimage) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage)
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::release_productimage() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_ImageMessage* temp = _impl_.productimage_;
  _impl_.productimage_ = 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 ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::unsafe_arena_release_productimage() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productImage)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_ImageMessage* temp = _impl_.productimage_;
  _impl_.productimage_ = nullptr;
  return temp;
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::_internal_mutable_productimage() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.productimage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
    _impl_.productimage_ = p;
  }
  return _impl_.productimage_;
}
inline ::proto::Message_ImageMessage* Message_ProductMessage_ProductSnapshot::mutable_productimage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_productimage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productImage)
  return _msg;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_productimage(::proto::Message_ImageMessage* productimage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.productimage_;
  }
  if (productimage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productimage);
    if (message_arena != submessage_arena) {
      productimage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, productimage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.productimage_ = productimage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productImage)
}

// optional string productId = 2;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_productid() const {
  return _internal_has_productid();
}
inline void Message_ProductMessage_ProductSnapshot::clear_productid() {
  _impl_.productid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::productid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productId)
  return _internal_productid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_productid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.productid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productId)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_productid() {
  std::string* _s = _internal_mutable_productid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.productId)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_productid() const {
  return _impl_.productid_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_productid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.productid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_productid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.productid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_productid() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.productId)
  if (!_internal_has_productid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.productid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_productid(std::string* productid) {
  if (productid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.productid_.SetAllocated(productid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.productid_.IsDefault()) {
    _impl_.productid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.productId)
}

// optional string title = 3;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_title() const {
  return _internal_has_title();
}
inline void Message_ProductMessage_ProductSnapshot::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::title() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::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:proto.Message.ProductMessage.ProductSnapshot.title)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.title)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_title() const {
  return _impl_.title_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_title() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.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 Message_ProductMessage_ProductSnapshot::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:proto.Message.ProductMessage.ProductSnapshot.title)
}

// optional string description = 4;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_description() const {
  return _internal_has_description();
}
inline void Message_ProductMessage_ProductSnapshot::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::description() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.description)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.description)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_description() const {
  return _impl_.description_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_description() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.description)
}

// optional string currencyCode = 5;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_currencycode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_currencycode() const {
  return _internal_has_currencycode();
}
inline void Message_ProductMessage_ProductSnapshot::clear_currencycode() {
  _impl_.currencycode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::currencycode() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
  return _internal_currencycode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_currencycode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_currencycode() {
  std::string* _s = _internal_mutable_currencycode();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_currencycode() const {
  return _impl_.currencycode_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_currencycode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.currencycode_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_currencycode() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_currencycode() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
  if (!_internal_has_currencycode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.currencycode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_currencycode(std::string* currencycode) {
  if (currencycode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.currencyCode)
}

// optional int64 priceAmount1000 = 6;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_priceamount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_priceamount1000() const {
  return _internal_has_priceamount1000();
}
inline void Message_ProductMessage_ProductSnapshot::clear_priceamount1000() {
  _impl_.priceamount1000_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline int64_t Message_ProductMessage_ProductSnapshot::_internal_priceamount1000() const {
  return _impl_.priceamount1000_;
}
inline int64_t Message_ProductMessage_ProductSnapshot::priceamount1000() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000)
  return _internal_priceamount1000();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_priceamount1000(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.priceamount1000_ = value;
}
inline void Message_ProductMessage_ProductSnapshot::set_priceamount1000(int64_t value) {
  _internal_set_priceamount1000(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.priceAmount1000)
}

// optional string retailerId = 7;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_retailerid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_retailerid() const {
  return _internal_has_retailerid();
}
inline void Message_ProductMessage_ProductSnapshot::clear_retailerid() {
  _impl_.retailerid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::retailerid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.retailerId)
  return _internal_retailerid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_retailerid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.retailerid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.retailerId)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_retailerid() {
  std::string* _s = _internal_mutable_retailerid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.retailerId)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_retailerid() const {
  return _impl_.retailerid_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_retailerid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.retailerid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_retailerid() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.retailerid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_retailerid() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.retailerId)
  if (!_internal_has_retailerid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.retailerid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.retailerid_.IsDefault()) {
    _impl_.retailerid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_retailerid(std::string* retailerid) {
  if (retailerid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.retailerid_.SetAllocated(retailerid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.retailerid_.IsDefault()) {
    _impl_.retailerid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.retailerId)
}

// optional string url = 8;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_url() const {
  return _internal_has_url();
}
inline void Message_ProductMessage_ProductSnapshot::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_url(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.url)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.url)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.url)
  if (!_internal_has_url()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  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 Message_ProductMessage_ProductSnapshot::set_allocated_url(std::string* url) {
  if (url != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _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:proto.Message.ProductMessage.ProductSnapshot.url)
}

// optional uint32 productImageCount = 9;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_productimagecount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_productimagecount() const {
  return _internal_has_productimagecount();
}
inline void Message_ProductMessage_ProductSnapshot::clear_productimagecount() {
  _impl_.productimagecount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Message_ProductMessage_ProductSnapshot::_internal_productimagecount() const {
  return _impl_.productimagecount_;
}
inline uint32_t Message_ProductMessage_ProductSnapshot::productimagecount() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.productImageCount)
  return _internal_productimagecount();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_productimagecount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.productimagecount_ = value;
}
inline void Message_ProductMessage_ProductSnapshot::set_productimagecount(uint32_t value) {
  _internal_set_productimagecount(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.productImageCount)
}

// optional string firstImageId = 11;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_firstimageid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_firstimageid() const {
  return _internal_has_firstimageid();
}
inline void Message_ProductMessage_ProductSnapshot::clear_firstimageid() {
  _impl_.firstimageid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::firstimageid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
  return _internal_firstimageid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage_ProductSnapshot::set_firstimageid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.firstimageid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
}
inline std::string* Message_ProductMessage_ProductSnapshot::mutable_firstimageid() {
  std::string* _s = _internal_mutable_firstimageid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
  return _s;
}
inline const std::string& Message_ProductMessage_ProductSnapshot::_internal_firstimageid() const {
  return _impl_.firstimageid_.Get();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_firstimageid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.firstimageid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::_internal_mutable_firstimageid() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.firstimageid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage_ProductSnapshot::release_firstimageid() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
  if (!_internal_has_firstimageid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.firstimageid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstimageid_.IsDefault()) {
    _impl_.firstimageid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage_ProductSnapshot::set_allocated_firstimageid(std::string* firstimageid) {
  if (firstimageid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.firstimageid_.SetAllocated(firstimageid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstimageid_.IsDefault()) {
    _impl_.firstimageid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.ProductSnapshot.firstImageId)
}

// optional int64 salePriceAmount1000 = 12;
inline bool Message_ProductMessage_ProductSnapshot::_internal_has_salepriceamount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_ProductMessage_ProductSnapshot::has_salepriceamount1000() const {
  return _internal_has_salepriceamount1000();
}
inline void Message_ProductMessage_ProductSnapshot::clear_salepriceamount1000() {
  _impl_.salepriceamount1000_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline int64_t Message_ProductMessage_ProductSnapshot::_internal_salepriceamount1000() const {
  return _impl_.salepriceamount1000_;
}
inline int64_t Message_ProductMessage_ProductSnapshot::salepriceamount1000() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000)
  return _internal_salepriceamount1000();
}
inline void Message_ProductMessage_ProductSnapshot::_internal_set_salepriceamount1000(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.salepriceamount1000_ = value;
}
inline void Message_ProductMessage_ProductSnapshot::set_salepriceamount1000(int64_t value) {
  _internal_set_salepriceamount1000(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.ProductSnapshot.salePriceAmount1000)
}

// -------------------------------------------------------------------

// Message_ProductMessage

// optional .proto.Message.ProductMessage.ProductSnapshot product = 1;
inline bool Message_ProductMessage::_internal_has_product() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.product_ != nullptr);
  return value;
}
inline bool Message_ProductMessage::has_product() const {
  return _internal_has_product();
}
inline void Message_ProductMessage::clear_product() {
  if (_impl_.product_ != nullptr) _impl_.product_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::_internal_product() const {
  const ::proto::Message_ProductMessage_ProductSnapshot* p = _impl_.product_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage_ProductSnapshot&>(
      ::proto::_Message_ProductMessage_ProductSnapshot_default_instance_);
}
inline const ::proto::Message_ProductMessage_ProductSnapshot& Message_ProductMessage::product() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.product)
  return _internal_product();
}
inline void Message_ProductMessage::unsafe_arena_set_allocated_product(
    ::proto::Message_ProductMessage_ProductSnapshot* product) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.product_);
  }
  _impl_.product_ = product;
  if (product) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.product)
}
inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::release_product() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_;
  _impl_.product_ = 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 ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::unsafe_arena_release_product() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.product)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_ProductMessage_ProductSnapshot* temp = _impl_.product_;
  _impl_.product_ = nullptr;
  return temp;
}
inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::_internal_mutable_product() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.product_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_ProductSnapshot>(GetArenaForAllocation());
    _impl_.product_ = p;
  }
  return _impl_.product_;
}
inline ::proto::Message_ProductMessage_ProductSnapshot* Message_ProductMessage::mutable_product() {
  ::proto::Message_ProductMessage_ProductSnapshot* _msg = _internal_mutable_product();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.product)
  return _msg;
}
inline void Message_ProductMessage::set_allocated_product(::proto::Message_ProductMessage_ProductSnapshot* product) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.product_;
  }
  if (product) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(product);
    if (message_arena != submessage_arena) {
      product = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, product, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.product_ = product;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.product)
}

// optional string businessOwnerJid = 2;
inline bool Message_ProductMessage::_internal_has_businessownerjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ProductMessage::has_businessownerjid() const {
  return _internal_has_businessownerjid();
}
inline void Message_ProductMessage::clear_businessownerjid() {
  _impl_.businessownerjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ProductMessage::businessownerjid() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.businessOwnerJid)
  return _internal_businessownerjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage::set_businessownerjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.businessownerjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.businessOwnerJid)
}
inline std::string* Message_ProductMessage::mutable_businessownerjid() {
  std::string* _s = _internal_mutable_businessownerjid();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.businessOwnerJid)
  return _s;
}
inline const std::string& Message_ProductMessage::_internal_businessownerjid() const {
  return _impl_.businessownerjid_.Get();
}
inline void Message_ProductMessage::_internal_set_businessownerjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.businessownerjid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::_internal_mutable_businessownerjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.businessownerjid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::release_businessownerjid() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.businessOwnerJid)
  if (!_internal_has_businessownerjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.businessownerjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.businessownerjid_.IsDefault()) {
    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage::set_allocated_businessownerjid(std::string* businessownerjid) {
  if (businessownerjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.businessownerjid_.SetAllocated(businessownerjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.businessownerjid_.IsDefault()) {
    _impl_.businessownerjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.businessOwnerJid)
}

// optional .proto.Message.ProductMessage.CatalogSnapshot catalog = 4;
inline bool Message_ProductMessage::_internal_has_catalog() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.catalog_ != nullptr);
  return value;
}
inline bool Message_ProductMessage::has_catalog() const {
  return _internal_has_catalog();
}
inline void Message_ProductMessage::clear_catalog() {
  if (_impl_.catalog_ != nullptr) _impl_.catalog_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::_internal_catalog() const {
  const ::proto::Message_ProductMessage_CatalogSnapshot* p = _impl_.catalog_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage_CatalogSnapshot&>(
      ::proto::_Message_ProductMessage_CatalogSnapshot_default_instance_);
}
inline const ::proto::Message_ProductMessage_CatalogSnapshot& Message_ProductMessage::catalog() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.catalog)
  return _internal_catalog();
}
inline void Message_ProductMessage::unsafe_arena_set_allocated_catalog(
    ::proto::Message_ProductMessage_CatalogSnapshot* catalog) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.catalog_);
  }
  _impl_.catalog_ = catalog;
  if (catalog) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.catalog)
}
inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::release_catalog() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_;
  _impl_.catalog_ = 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 ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::unsafe_arena_release_catalog() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.catalog)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_ProductMessage_CatalogSnapshot* temp = _impl_.catalog_;
  _impl_.catalog_ = nullptr;
  return temp;
}
inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::_internal_mutable_catalog() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.catalog_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage_CatalogSnapshot>(GetArenaForAllocation());
    _impl_.catalog_ = p;
  }
  return _impl_.catalog_;
}
inline ::proto::Message_ProductMessage_CatalogSnapshot* Message_ProductMessage::mutable_catalog() {
  ::proto::Message_ProductMessage_CatalogSnapshot* _msg = _internal_mutable_catalog();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.catalog)
  return _msg;
}
inline void Message_ProductMessage::set_allocated_catalog(::proto::Message_ProductMessage_CatalogSnapshot* catalog) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.catalog_;
  }
  if (catalog) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(catalog);
    if (message_arena != submessage_arena) {
      catalog = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, catalog, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.catalog_ = catalog;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.catalog)
}

// optional string body = 5;
inline bool Message_ProductMessage::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ProductMessage::has_body() const {
  return _internal_has_body();
}
inline void Message_ProductMessage::clear_body() {
  _impl_.body_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ProductMessage::body() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage::set_body(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.body_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.body)
}
inline std::string* Message_ProductMessage::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.body)
  return _s;
}
inline const std::string& Message_ProductMessage::_internal_body() const {
  return _impl_.body_.Get();
}
inline void Message_ProductMessage::_internal_set_body(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.body_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.body_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::release_body() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.body)
  if (!_internal_has_body()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 Message_ProductMessage::set_allocated_body(std::string* body) {
  if (body != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:proto.Message.ProductMessage.body)
}

// optional string footer = 6;
inline bool Message_ProductMessage::_internal_has_footer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_ProductMessage::has_footer() const {
  return _internal_has_footer();
}
inline void Message_ProductMessage::clear_footer() {
  _impl_.footer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_ProductMessage::footer() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.footer)
  return _internal_footer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ProductMessage::set_footer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.footer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ProductMessage.footer)
}
inline std::string* Message_ProductMessage::mutable_footer() {
  std::string* _s = _internal_mutable_footer();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.footer)
  return _s;
}
inline const std::string& Message_ProductMessage::_internal_footer() const {
  return _impl_.footer_.Get();
}
inline void Message_ProductMessage::_internal_set_footer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.footer_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::_internal_mutable_footer() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.footer_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ProductMessage::release_footer() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.footer)
  if (!_internal_has_footer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.footer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footer_.IsDefault()) {
    _impl_.footer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ProductMessage::set_allocated_footer(std::string* footer) {
  if (footer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.footer_.SetAllocated(footer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.footer_.IsDefault()) {
    _impl_.footer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.footer)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_ProductMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_ProductMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_ProductMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ContextInfo& Message_ProductMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_ProductMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProductMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_ProductMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProductMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_ProductMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_ProductMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.ProductMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_ProductMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_ProductMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProductMessage.contextInfo)
  return _msg;
}
inline void Message_ProductMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProductMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_ProtocolMessage

// optional .proto.MessageKey key = 1;
inline bool Message_ProtocolMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_key() const {
  return _internal_has_key();
}
inline void Message_ProtocolMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& Message_ProtocolMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_ProtocolMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.key)
  return _internal_key();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.key)
}
inline ::proto::MessageKey* Message_ProtocolMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Message_ProtocolMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_ProtocolMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Message_ProtocolMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.key)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.key)
}

// optional .proto.Message.ProtocolMessage.Type type = 2;
inline bool Message_ProtocolMessage::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_ProtocolMessage::has_type() const {
  return _internal_has_type();
}
inline void Message_ProtocolMessage::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::_internal_type() const {
  return static_cast< ::proto::Message_ProtocolMessage_Type >(_impl_.type_);
}
inline ::proto::Message_ProtocolMessage_Type Message_ProtocolMessage::type() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.type)
  return _internal_type();
}
inline void Message_ProtocolMessage::_internal_set_type(::proto::Message_ProtocolMessage_Type value) {
  assert(::proto::Message_ProtocolMessage_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.type_ = value;
}
inline void Message_ProtocolMessage::set_type(::proto::Message_ProtocolMessage_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.type)
}

// optional uint32 ephemeralExpiration = 4;
inline bool Message_ProtocolMessage::_internal_has_ephemeralexpiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_ProtocolMessage::has_ephemeralexpiration() const {
  return _internal_has_ephemeralexpiration();
}
inline void Message_ProtocolMessage::clear_ephemeralexpiration() {
  _impl_.ephemeralexpiration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Message_ProtocolMessage::_internal_ephemeralexpiration() const {
  return _impl_.ephemeralexpiration_;
}
inline uint32_t Message_ProtocolMessage::ephemeralexpiration() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralExpiration)
  return _internal_ephemeralexpiration();
}
inline void Message_ProtocolMessage::_internal_set_ephemeralexpiration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.ephemeralexpiration_ = value;
}
inline void Message_ProtocolMessage::set_ephemeralexpiration(uint32_t value) {
  _internal_set_ephemeralexpiration(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralExpiration)
}

// optional int64 ephemeralSettingTimestamp = 5;
inline bool Message_ProtocolMessage::_internal_has_ephemeralsettingtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_ProtocolMessage::has_ephemeralsettingtimestamp() const {
  return _internal_has_ephemeralsettingtimestamp();
}
inline void Message_ProtocolMessage::clear_ephemeralsettingtimestamp() {
  _impl_.ephemeralsettingtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline int64_t Message_ProtocolMessage::_internal_ephemeralsettingtimestamp() const {
  return _impl_.ephemeralsettingtimestamp_;
}
inline int64_t Message_ProtocolMessage::ephemeralsettingtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.ephemeralSettingTimestamp)
  return _internal_ephemeralsettingtimestamp();
}
inline void Message_ProtocolMessage::_internal_set_ephemeralsettingtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.ephemeralsettingtimestamp_ = value;
}
inline void Message_ProtocolMessage::set_ephemeralsettingtimestamp(int64_t value) {
  _internal_set_ephemeralsettingtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.ProtocolMessage.ephemeralSettingTimestamp)
}

// optional .proto.Message.HistorySyncNotification historySyncNotification = 6;
inline bool Message_ProtocolMessage::_internal_has_historysyncnotification() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.historysyncnotification_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_historysyncnotification() const {
  return _internal_has_historysyncnotification();
}
inline void Message_ProtocolMessage::clear_historysyncnotification() {
  if (_impl_.historysyncnotification_ != nullptr) _impl_.historysyncnotification_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::_internal_historysyncnotification() const {
  const ::proto::Message_HistorySyncNotification* p = _impl_.historysyncnotification_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HistorySyncNotification&>(
      ::proto::_Message_HistorySyncNotification_default_instance_);
}
inline const ::proto::Message_HistorySyncNotification& Message_ProtocolMessage::historysyncnotification() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.historySyncNotification)
  return _internal_historysyncnotification();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_historysyncnotification(
    ::proto::Message_HistorySyncNotification* historysyncnotification) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.historysyncnotification_);
  }
  _impl_.historysyncnotification_ = historysyncnotification;
  if (historysyncnotification) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.historySyncNotification)
}
inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::release_historysyncnotification() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_;
  _impl_.historysyncnotification_ = 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 ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::unsafe_arena_release_historysyncnotification() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.historySyncNotification)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HistorySyncNotification* temp = _impl_.historysyncnotification_;
  _impl_.historysyncnotification_ = nullptr;
  return temp;
}
inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::_internal_mutable_historysyncnotification() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.historysyncnotification_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HistorySyncNotification>(GetArenaForAllocation());
    _impl_.historysyncnotification_ = p;
  }
  return _impl_.historysyncnotification_;
}
inline ::proto::Message_HistorySyncNotification* Message_ProtocolMessage::mutable_historysyncnotification() {
  ::proto::Message_HistorySyncNotification* _msg = _internal_mutable_historysyncnotification();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.historySyncNotification)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_historysyncnotification(::proto::Message_HistorySyncNotification* historysyncnotification) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.historysyncnotification_;
  }
  if (historysyncnotification) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(historysyncnotification);
    if (message_arena != submessage_arena) {
      historysyncnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, historysyncnotification, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.historysyncnotification_ = historysyncnotification;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.historySyncNotification)
}

// optional .proto.Message.AppStateSyncKeyShare appStateSyncKeyShare = 7;
inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyshare() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyshare_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_appstatesynckeyshare() const {
  return _internal_has_appstatesynckeyshare();
}
inline void Message_ProtocolMessage::clear_appstatesynckeyshare() {
  if (_impl_.appstatesynckeyshare_ != nullptr) _impl_.appstatesynckeyshare_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::_internal_appstatesynckeyshare() const {
  const ::proto::Message_AppStateSyncKeyShare* p = _impl_.appstatesynckeyshare_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyShare&>(
      ::proto::_Message_AppStateSyncKeyShare_default_instance_);
}
inline const ::proto::Message_AppStateSyncKeyShare& Message_ProtocolMessage::appstatesynckeyshare() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyShare)
  return _internal_appstatesynckeyshare();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyshare(
    ::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyshare_);
  }
  _impl_.appstatesynckeyshare_ = appstatesynckeyshare;
  if (appstatesynckeyshare) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare)
}
inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::release_appstatesynckeyshare() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_;
  _impl_.appstatesynckeyshare_ = 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 ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyshare() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyShare)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_AppStateSyncKeyShare* temp = _impl_.appstatesynckeyshare_;
  _impl_.appstatesynckeyshare_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::_internal_mutable_appstatesynckeyshare() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.appstatesynckeyshare_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyShare>(GetArenaForAllocation());
    _impl_.appstatesynckeyshare_ = p;
  }
  return _impl_.appstatesynckeyshare_;
}
inline ::proto::Message_AppStateSyncKeyShare* Message_ProtocolMessage::mutable_appstatesynckeyshare() {
  ::proto::Message_AppStateSyncKeyShare* _msg = _internal_mutable_appstatesynckeyshare();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyShare)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_appstatesynckeyshare(::proto::Message_AppStateSyncKeyShare* appstatesynckeyshare) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.appstatesynckeyshare_;
  }
  if (appstatesynckeyshare) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyshare);
    if (message_arena != submessage_arena) {
      appstatesynckeyshare = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, appstatesynckeyshare, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.appstatesynckeyshare_ = appstatesynckeyshare;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyShare)
}

// optional .proto.Message.AppStateSyncKeyRequest appStateSyncKeyRequest = 8;
inline bool Message_ProtocolMessage::_internal_has_appstatesynckeyrequest() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.appstatesynckeyrequest_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_appstatesynckeyrequest() const {
  return _internal_has_appstatesynckeyrequest();
}
inline void Message_ProtocolMessage::clear_appstatesynckeyrequest() {
  if (_impl_.appstatesynckeyrequest_ != nullptr) _impl_.appstatesynckeyrequest_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::_internal_appstatesynckeyrequest() const {
  const ::proto::Message_AppStateSyncKeyRequest* p = _impl_.appstatesynckeyrequest_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateSyncKeyRequest&>(
      ::proto::_Message_AppStateSyncKeyRequest_default_instance_);
}
inline const ::proto::Message_AppStateSyncKeyRequest& Message_ProtocolMessage::appstatesynckeyrequest() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
  return _internal_appstatesynckeyrequest();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatesynckeyrequest(
    ::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatesynckeyrequest_);
  }
  _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest;
  if (appstatesynckeyrequest) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
}
inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::release_appstatesynckeyrequest() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_;
  _impl_.appstatesynckeyrequest_ = 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 ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::unsafe_arena_release_appstatesynckeyrequest() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_AppStateSyncKeyRequest* temp = _impl_.appstatesynckeyrequest_;
  _impl_.appstatesynckeyrequest_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::_internal_mutable_appstatesynckeyrequest() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.appstatesynckeyrequest_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateSyncKeyRequest>(GetArenaForAllocation());
    _impl_.appstatesynckeyrequest_ = p;
  }
  return _impl_.appstatesynckeyrequest_;
}
inline ::proto::Message_AppStateSyncKeyRequest* Message_ProtocolMessage::mutable_appstatesynckeyrequest() {
  ::proto::Message_AppStateSyncKeyRequest* _msg = _internal_mutable_appstatesynckeyrequest();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_appstatesynckeyrequest(::proto::Message_AppStateSyncKeyRequest* appstatesynckeyrequest) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.appstatesynckeyrequest_;
  }
  if (appstatesynckeyrequest) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatesynckeyrequest);
    if (message_arena != submessage_arena) {
      appstatesynckeyrequest = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, appstatesynckeyrequest, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.appstatesynckeyrequest_ = appstatesynckeyrequest;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateSyncKeyRequest)
}

// optional .proto.Message.InitialSecurityNotificationSettingSync initialSecurityNotificationSettingSync = 9;
inline bool Message_ProtocolMessage::_internal_has_initialsecuritynotificationsettingsync() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.initialsecuritynotificationsettingsync_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_initialsecuritynotificationsettingsync() const {
  return _internal_has_initialsecuritynotificationsettingsync();
}
inline void Message_ProtocolMessage::clear_initialsecuritynotificationsettingsync() {
  if (_impl_.initialsecuritynotificationsettingsync_ != nullptr) _impl_.initialsecuritynotificationsettingsync_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::_internal_initialsecuritynotificationsettingsync() const {
  const ::proto::Message_InitialSecurityNotificationSettingSync* p = _impl_.initialsecuritynotificationsettingsync_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InitialSecurityNotificationSettingSync&>(
      ::proto::_Message_InitialSecurityNotificationSettingSync_default_instance_);
}
inline const ::proto::Message_InitialSecurityNotificationSettingSync& Message_ProtocolMessage::initialsecuritynotificationsettingsync() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
  return _internal_initialsecuritynotificationsettingsync();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_initialsecuritynotificationsettingsync(
    ::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.initialsecuritynotificationsettingsync_);
  }
  _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync;
  if (initialsecuritynotificationsettingsync) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
}
inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::release_initialsecuritynotificationsettingsync() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_;
  _impl_.initialsecuritynotificationsettingsync_ = 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 ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::unsafe_arena_release_initialsecuritynotificationsettingsync() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_InitialSecurityNotificationSettingSync* temp = _impl_.initialsecuritynotificationsettingsync_;
  _impl_.initialsecuritynotificationsettingsync_ = nullptr;
  return temp;
}
inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::_internal_mutable_initialsecuritynotificationsettingsync() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.initialsecuritynotificationsettingsync_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InitialSecurityNotificationSettingSync>(GetArenaForAllocation());
    _impl_.initialsecuritynotificationsettingsync_ = p;
  }
  return _impl_.initialsecuritynotificationsettingsync_;
}
inline ::proto::Message_InitialSecurityNotificationSettingSync* Message_ProtocolMessage::mutable_initialsecuritynotificationsettingsync() {
  ::proto::Message_InitialSecurityNotificationSettingSync* _msg = _internal_mutable_initialsecuritynotificationsettingsync();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_initialsecuritynotificationsettingsync(::proto::Message_InitialSecurityNotificationSettingSync* initialsecuritynotificationsettingsync) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.initialsecuritynotificationsettingsync_;
  }
  if (initialsecuritynotificationsettingsync) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initialsecuritynotificationsettingsync);
    if (message_arena != submessage_arena) {
      initialsecuritynotificationsettingsync = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, initialsecuritynotificationsettingsync, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.initialsecuritynotificationsettingsync_ = initialsecuritynotificationsettingsync;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.initialSecurityNotificationSettingSync)
}

// optional .proto.Message.AppStateFatalExceptionNotification appStateFatalExceptionNotification = 10;
inline bool Message_ProtocolMessage::_internal_has_appstatefatalexceptionnotification() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.appstatefatalexceptionnotification_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_appstatefatalexceptionnotification() const {
  return _internal_has_appstatefatalexceptionnotification();
}
inline void Message_ProtocolMessage::clear_appstatefatalexceptionnotification() {
  if (_impl_.appstatefatalexceptionnotification_ != nullptr) _impl_.appstatefatalexceptionnotification_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::_internal_appstatefatalexceptionnotification() const {
  const ::proto::Message_AppStateFatalExceptionNotification* p = _impl_.appstatefatalexceptionnotification_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AppStateFatalExceptionNotification&>(
      ::proto::_Message_AppStateFatalExceptionNotification_default_instance_);
}
inline const ::proto::Message_AppStateFatalExceptionNotification& Message_ProtocolMessage::appstatefatalexceptionnotification() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
  return _internal_appstatefatalexceptionnotification();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_appstatefatalexceptionnotification(
    ::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.appstatefatalexceptionnotification_);
  }
  _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification;
  if (appstatefatalexceptionnotification) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
}
inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::release_appstatefatalexceptionnotification() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_;
  _impl_.appstatefatalexceptionnotification_ = 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 ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::unsafe_arena_release_appstatefatalexceptionnotification() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::Message_AppStateFatalExceptionNotification* temp = _impl_.appstatefatalexceptionnotification_;
  _impl_.appstatefatalexceptionnotification_ = nullptr;
  return temp;
}
inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::_internal_mutable_appstatefatalexceptionnotification() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.appstatefatalexceptionnotification_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AppStateFatalExceptionNotification>(GetArenaForAllocation());
    _impl_.appstatefatalexceptionnotification_ = p;
  }
  return _impl_.appstatefatalexceptionnotification_;
}
inline ::proto::Message_AppStateFatalExceptionNotification* Message_ProtocolMessage::mutable_appstatefatalexceptionnotification() {
  ::proto::Message_AppStateFatalExceptionNotification* _msg = _internal_mutable_appstatefatalexceptionnotification();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_appstatefatalexceptionnotification(::proto::Message_AppStateFatalExceptionNotification* appstatefatalexceptionnotification) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.appstatefatalexceptionnotification_;
  }
  if (appstatefatalexceptionnotification) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(appstatefatalexceptionnotification);
    if (message_arena != submessage_arena) {
      appstatefatalexceptionnotification = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, appstatefatalexceptionnotification, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.appstatefatalexceptionnotification_ = appstatefatalexceptionnotification;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.appStateFatalExceptionNotification)
}

// optional .proto.DisappearingMode disappearingMode = 11;
inline bool Message_ProtocolMessage::_internal_has_disappearingmode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.disappearingmode_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_disappearingmode() const {
  return _internal_has_disappearingmode();
}
inline void Message_ProtocolMessage::clear_disappearingmode() {
  if (_impl_.disappearingmode_ != nullptr) _impl_.disappearingmode_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::DisappearingMode& Message_ProtocolMessage::_internal_disappearingmode() const {
  const ::proto::DisappearingMode* p = _impl_.disappearingmode_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::DisappearingMode&>(
      ::proto::_DisappearingMode_default_instance_);
}
inline const ::proto::DisappearingMode& Message_ProtocolMessage::disappearingmode() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.disappearingMode)
  return _internal_disappearingmode();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_disappearingmode(
    ::proto::DisappearingMode* disappearingmode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.disappearingmode_);
  }
  _impl_.disappearingmode_ = disappearingmode;
  if (disappearingmode) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.disappearingMode)
}
inline ::proto::DisappearingMode* Message_ProtocolMessage::release_disappearingmode() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = 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 ::proto::DisappearingMode* Message_ProtocolMessage::unsafe_arena_release_disappearingmode() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.disappearingMode)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::DisappearingMode* temp = _impl_.disappearingmode_;
  _impl_.disappearingmode_ = nullptr;
  return temp;
}
inline ::proto::DisappearingMode* Message_ProtocolMessage::_internal_mutable_disappearingmode() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.disappearingmode_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::DisappearingMode>(GetArenaForAllocation());
    _impl_.disappearingmode_ = p;
  }
  return _impl_.disappearingmode_;
}
inline ::proto::DisappearingMode* Message_ProtocolMessage::mutable_disappearingmode() {
  ::proto::DisappearingMode* _msg = _internal_mutable_disappearingmode();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.disappearingMode)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_disappearingmode(::proto::DisappearingMode* disappearingmode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.disappearingmode_;
  }
  if (disappearingmode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(disappearingmode);
    if (message_arena != submessage_arena) {
      disappearingmode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, disappearingmode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.disappearingmode_ = disappearingmode;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.disappearingMode)
}

// optional .proto.Message.RequestMediaUploadMessage requestMediaUploadMessage = 12;
inline bool Message_ProtocolMessage::_internal_has_requestmediauploadmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestmediauploadmessage_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_requestmediauploadmessage() const {
  return _internal_has_requestmediauploadmessage();
}
inline void Message_ProtocolMessage::clear_requestmediauploadmessage() {
  if (_impl_.requestmediauploadmessage_ != nullptr) _impl_.requestmediauploadmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::_internal_requestmediauploadmessage() const {
  const ::proto::Message_RequestMediaUploadMessage* p = _impl_.requestmediauploadmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestMediaUploadMessage&>(
      ::proto::_Message_RequestMediaUploadMessage_default_instance_);
}
inline const ::proto::Message_RequestMediaUploadMessage& Message_ProtocolMessage::requestmediauploadmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadMessage)
  return _internal_requestmediauploadmessage();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadmessage(
    ::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadmessage_);
  }
  _impl_.requestmediauploadmessage_ = requestmediauploadmessage;
  if (requestmediauploadmessage) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage)
}
inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::release_requestmediauploadmessage() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_;
  _impl_.requestmediauploadmessage_ = 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 ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadMessage)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_RequestMediaUploadMessage* temp = _impl_.requestmediauploadmessage_;
  _impl_.requestmediauploadmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadmessage() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.requestmediauploadmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadMessage>(GetArenaForAllocation());
    _impl_.requestmediauploadmessage_ = p;
  }
  return _impl_.requestmediauploadmessage_;
}
inline ::proto::Message_RequestMediaUploadMessage* Message_ProtocolMessage::mutable_requestmediauploadmessage() {
  ::proto::Message_RequestMediaUploadMessage* _msg = _internal_mutable_requestmediauploadmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadMessage)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_requestmediauploadmessage(::proto::Message_RequestMediaUploadMessage* requestmediauploadmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestmediauploadmessage_;
  }
  if (requestmediauploadmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadmessage);
    if (message_arena != submessage_arena) {
      requestmediauploadmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestmediauploadmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.requestmediauploadmessage_ = requestmediauploadmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadMessage)
}

// optional .proto.Message.RequestMediaUploadResponseMessage requestMediaUploadResponseMessage = 13;
inline bool Message_ProtocolMessage::_internal_has_requestmediauploadresponsemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestmediauploadresponsemessage_ != nullptr);
  return value;
}
inline bool Message_ProtocolMessage::has_requestmediauploadresponsemessage() const {
  return _internal_has_requestmediauploadresponsemessage();
}
inline void Message_ProtocolMessage::clear_requestmediauploadresponsemessage() {
  if (_impl_.requestmediauploadresponsemessage_ != nullptr) _impl_.requestmediauploadresponsemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::_internal_requestmediauploadresponsemessage() const {
  const ::proto::Message_RequestMediaUploadResponseMessage* p = _impl_.requestmediauploadresponsemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestMediaUploadResponseMessage&>(
      ::proto::_Message_RequestMediaUploadResponseMessage_default_instance_);
}
inline const ::proto::Message_RequestMediaUploadResponseMessage& Message_ProtocolMessage::requestmediauploadresponsemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
  return _internal_requestmediauploadresponsemessage();
}
inline void Message_ProtocolMessage::unsafe_arena_set_allocated_requestmediauploadresponsemessage(
    ::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmediauploadresponsemessage_);
  }
  _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage;
  if (requestmediauploadresponsemessage) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
}
inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::release_requestmediauploadresponsemessage() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_;
  _impl_.requestmediauploadresponsemessage_ = 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 ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::unsafe_arena_release_requestmediauploadresponsemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::Message_RequestMediaUploadResponseMessage* temp = _impl_.requestmediauploadresponsemessage_;
  _impl_.requestmediauploadresponsemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::_internal_mutable_requestmediauploadresponsemessage() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.requestmediauploadresponsemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_RequestMediaUploadResponseMessage>(GetArenaForAllocation());
    _impl_.requestmediauploadresponsemessage_ = p;
  }
  return _impl_.requestmediauploadresponsemessage_;
}
inline ::proto::Message_RequestMediaUploadResponseMessage* Message_ProtocolMessage::mutable_requestmediauploadresponsemessage() {
  ::proto::Message_RequestMediaUploadResponseMessage* _msg = _internal_mutable_requestmediauploadresponsemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
  return _msg;
}
inline void Message_ProtocolMessage::set_allocated_requestmediauploadresponsemessage(::proto::Message_RequestMediaUploadResponseMessage* requestmediauploadresponsemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestmediauploadresponsemessage_;
  }
  if (requestmediauploadresponsemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmediauploadresponsemessage);
    if (message_arena != submessage_arena) {
      requestmediauploadresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestmediauploadresponsemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.requestmediauploadresponsemessage_ = requestmediauploadresponsemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ProtocolMessage.requestMediaUploadResponseMessage)
}

// -------------------------------------------------------------------

// Message_ReactionMessage

// optional .proto.MessageKey key = 1;
inline bool Message_ReactionMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Message_ReactionMessage::has_key() const {
  return _internal_has_key();
}
inline void Message_ReactionMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::MessageKey& Message_ReactionMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_ReactionMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.key)
  return _internal_key();
}
inline void Message_ReactionMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ReactionMessage.key)
}
inline ::proto::MessageKey* Message_ReactionMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Message_ReactionMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.key)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_ReactionMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Message_ReactionMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.key)
  return _msg;
}
inline void Message_ReactionMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.key)
}

// optional string text = 2;
inline bool Message_ReactionMessage::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_ReactionMessage::has_text() const {
  return _internal_has_text();
}
inline void Message_ReactionMessage::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_ReactionMessage::text() const {
  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ReactionMessage::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.text)
}
inline std::string* Message_ReactionMessage::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.text)
  return _s;
}
inline const std::string& Message_ReactionMessage::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Message_ReactionMessage::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ReactionMessage::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ReactionMessage::release_text() {
  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Message_ReactionMessage::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Message.ReactionMessage.text)
}

// optional string groupingKey = 3;
inline bool Message_ReactionMessage::_internal_has_groupingkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_ReactionMessage::has_groupingkey() const {
  return _internal_has_groupingkey();
}
inline void Message_ReactionMessage::clear_groupingkey() {
  _impl_.groupingkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_ReactionMessage::groupingkey() const {
  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.groupingKey)
  return _internal_groupingkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_ReactionMessage::set_groupingkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.groupingkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.groupingKey)
}
inline std::string* Message_ReactionMessage::mutable_groupingkey() {
  std::string* _s = _internal_mutable_groupingkey();
  // @@protoc_insertion_point(field_mutable:proto.Message.ReactionMessage.groupingKey)
  return _s;
}
inline const std::string& Message_ReactionMessage::_internal_groupingkey() const {
  return _impl_.groupingkey_.Get();
}
inline void Message_ReactionMessage::_internal_set_groupingkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.groupingkey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_ReactionMessage::_internal_mutable_groupingkey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.groupingkey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_ReactionMessage::release_groupingkey() {
  // @@protoc_insertion_point(field_release:proto.Message.ReactionMessage.groupingKey)
  if (!_internal_has_groupingkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.groupingkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupingkey_.IsDefault()) {
    _impl_.groupingkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_ReactionMessage::set_allocated_groupingkey(std::string* groupingkey) {
  if (groupingkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupingkey_.IsDefault()) {
    _impl_.groupingkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ReactionMessage.groupingKey)
}

// optional int64 senderTimestampMs = 4;
inline bool Message_ReactionMessage::_internal_has_sendertimestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_ReactionMessage::has_sendertimestampms() const {
  return _internal_has_sendertimestampms();
}
inline void Message_ReactionMessage::clear_sendertimestampms() {
  _impl_.sendertimestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t Message_ReactionMessage::_internal_sendertimestampms() const {
  return _impl_.sendertimestampms_;
}
inline int64_t Message_ReactionMessage::sendertimestampms() const {
  // @@protoc_insertion_point(field_get:proto.Message.ReactionMessage.senderTimestampMs)
  return _internal_sendertimestampms();
}
inline void Message_ReactionMessage::_internal_set_sendertimestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.sendertimestampms_ = value;
}
inline void Message_ReactionMessage::set_sendertimestampms(int64_t value) {
  _internal_set_sendertimestampms(value);
  // @@protoc_insertion_point(field_set:proto.Message.ReactionMessage.senderTimestampMs)
}

// -------------------------------------------------------------------

// Message_RequestMediaUploadMessage

// repeated string fileSha256 = 1;
inline int Message_RequestMediaUploadMessage::_internal_filesha256_size() const {
  return _impl_.filesha256_.size();
}
inline int Message_RequestMediaUploadMessage::filesha256_size() const {
  return _internal_filesha256_size();
}
inline void Message_RequestMediaUploadMessage::clear_filesha256() {
  _impl_.filesha256_.Clear();
}
inline std::string* Message_RequestMediaUploadMessage::add_filesha256() {
  std::string* _s = _internal_add_filesha256();
  // @@protoc_insertion_point(field_add_mutable:proto.Message.RequestMediaUploadMessage.fileSha256)
  return _s;
}
inline const std::string& Message_RequestMediaUploadMessage::_internal_filesha256(int index) const {
  return _impl_.filesha256_.Get(index);
}
inline const std::string& Message_RequestMediaUploadMessage::filesha256(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.fileSha256)
  return _internal_filesha256(index);
}
inline std::string* Message_RequestMediaUploadMessage::mutable_filesha256(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadMessage.fileSha256)
  return _impl_.filesha256_.Mutable(index);
}
inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const std::string& value) {
  _impl_.filesha256_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::set_filesha256(int index, std::string&& value) {
  _impl_.filesha256_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.filesha256_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::set_filesha256(int index, const char* value, size_t size) {
  _impl_.filesha256_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline std::string* Message_RequestMediaUploadMessage::_internal_add_filesha256() {
  return _impl_.filesha256_.Add();
}
inline void Message_RequestMediaUploadMessage::add_filesha256(const std::string& value) {
  _impl_.filesha256_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::add_filesha256(std::string&& value) {
  _impl_.filesha256_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.filesha256_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline void Message_RequestMediaUploadMessage::add_filesha256(const char* value, size_t size) {
  _impl_.filesha256_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.Message.RequestMediaUploadMessage.fileSha256)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Message_RequestMediaUploadMessage::filesha256() const {
  // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadMessage.fileSha256)
  return _impl_.filesha256_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Message_RequestMediaUploadMessage::mutable_filesha256() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadMessage.fileSha256)
  return &_impl_.filesha256_;
}

// optional .proto.Message.RmrSource rmrSource = 2;
inline bool Message_RequestMediaUploadMessage::_internal_has_rmrsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_RequestMediaUploadMessage::has_rmrsource() const {
  return _internal_has_rmrsource();
}
inline void Message_RequestMediaUploadMessage::clear_rmrsource() {
  _impl_.rmrsource_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::_internal_rmrsource() const {
  return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_);
}
inline ::proto::Message_RmrSource Message_RequestMediaUploadMessage::rmrsource() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadMessage.rmrSource)
  return _internal_rmrsource();
}
inline void Message_RequestMediaUploadMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) {
  assert(::proto::Message_RmrSource_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rmrsource_ = value;
}
inline void Message_RequestMediaUploadMessage::set_rmrsource(::proto::Message_RmrSource value) {
  _internal_set_rmrsource(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadMessage.rmrSource)
}

// -------------------------------------------------------------------

// Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult

// optional string fileSha256 = 1;
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.filesha256_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
}
inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
  return _s;
}
inline const std::string& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.fileSha256)
}

// optional .proto.MediaRetryNotification.ResultType mediaUploadResult = 2;
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_mediauploadresult() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_mediauploadresult() const {
  return _internal_has_mediauploadresult();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_mediauploadresult() {
  _impl_.mediauploadresult_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mediauploadresult() const {
  return static_cast< ::proto::MediaRetryNotification_ResultType >(_impl_.mediauploadresult_);
}
inline ::proto::MediaRetryNotification_ResultType Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mediauploadresult() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult)
  return _internal_mediauploadresult();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) {
  assert(::proto::MediaRetryNotification_ResultType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mediauploadresult_ = value;
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_mediauploadresult(::proto::MediaRetryNotification_ResultType value) {
  _internal_set_mediauploadresult(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.mediaUploadResult)
}

// optional .proto.Message.StickerMessage stickerMessage = 3;
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_has_stickermessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr);
  return value;
}
inline bool Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::has_stickermessage() const {
  return _internal_has_stickermessage();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::clear_stickermessage() {
  if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_stickermessage() const {
  const ::proto::Message_StickerMessage* p = _impl_.stickermessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerMessage&>(
      ::proto::_Message_StickerMessage_default_instance_);
}
inline const ::proto::Message_StickerMessage& Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::stickermessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
  return _internal_stickermessage();
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_set_allocated_stickermessage(
    ::proto::Message_StickerMessage* stickermessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_);
  }
  _impl_.stickermessage_ = stickermessage;
  if (stickermessage) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
}
inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::release_stickermessage() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
  _impl_.stickermessage_ = 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 ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::unsafe_arena_release_stickermessage() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
  _impl_.stickermessage_ = nullptr;
  return temp;
}
inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::_internal_mutable_stickermessage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.stickermessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation());
    _impl_.stickermessage_ = p;
  }
  return _impl_.stickermessage_;
}
inline ::proto::Message_StickerMessage* Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::mutable_stickermessage() {
  ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
  return _msg;
}
inline void Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stickermessage_;
  }
  if (stickermessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage);
    if (message_arena != submessage_arena) {
      stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stickermessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.stickermessage_ = stickermessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult.stickerMessage)
}

// -------------------------------------------------------------------

// Message_RequestMediaUploadResponseMessage

// optional .proto.Message.RmrSource rmrSource = 1;
inline bool Message_RequestMediaUploadResponseMessage::_internal_has_rmrsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_RequestMediaUploadResponseMessage::has_rmrsource() const {
  return _internal_has_rmrsource();
}
inline void Message_RequestMediaUploadResponseMessage::clear_rmrsource() {
  _impl_.rmrsource_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::_internal_rmrsource() const {
  return static_cast< ::proto::Message_RmrSource >(_impl_.rmrsource_);
}
inline ::proto::Message_RmrSource Message_RequestMediaUploadResponseMessage::rmrsource() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.rmrSource)
  return _internal_rmrsource();
}
inline void Message_RequestMediaUploadResponseMessage::_internal_set_rmrsource(::proto::Message_RmrSource value) {
  assert(::proto::Message_RmrSource_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.rmrsource_ = value;
}
inline void Message_RequestMediaUploadResponseMessage::set_rmrsource(::proto::Message_RmrSource value) {
  _internal_set_rmrsource(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.rmrSource)
}

// optional string stanzaId = 2;
inline bool Message_RequestMediaUploadResponseMessage::_internal_has_stanzaid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_RequestMediaUploadResponseMessage::has_stanzaid() const {
  return _internal_has_stanzaid();
}
inline void Message_RequestMediaUploadResponseMessage::clear_stanzaid() {
  _impl_.stanzaid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_RequestMediaUploadResponseMessage::stanzaid() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
  return _internal_stanzaid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_RequestMediaUploadResponseMessage::set_stanzaid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
}
inline std::string* Message_RequestMediaUploadResponseMessage::mutable_stanzaid() {
  std::string* _s = _internal_mutable_stanzaid();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
  return _s;
}
inline const std::string& Message_RequestMediaUploadResponseMessage::_internal_stanzaid() const {
  return _impl_.stanzaid_.Get();
}
inline void Message_RequestMediaUploadResponseMessage::_internal_set_stanzaid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_RequestMediaUploadResponseMessage::_internal_mutable_stanzaid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_RequestMediaUploadResponseMessage::release_stanzaid() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
  if (!_internal_has_stanzaid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.stanzaid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_RequestMediaUploadResponseMessage::set_allocated_stanzaid(std::string* stanzaid) {
  if (stanzaid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestMediaUploadResponseMessage.stanzaId)
}

// repeated .proto.Message.RequestMediaUploadResponseMessage.RequestMediaUploadResult reuploadResult = 3;
inline int Message_RequestMediaUploadResponseMessage::_internal_reuploadresult_size() const {
  return _impl_.reuploadresult_.size();
}
inline int Message_RequestMediaUploadResponseMessage::reuploadresult_size() const {
  return _internal_reuploadresult_size();
}
inline void Message_RequestMediaUploadResponseMessage::clear_reuploadresult() {
  _impl_.reuploadresult_.Clear();
}
inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::mutable_reuploadresult(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
  return _impl_.reuploadresult_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >*
Message_RequestMediaUploadResponseMessage::mutable_reuploadresult() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
  return &_impl_.reuploadresult_;
}
inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::_internal_reuploadresult(int index) const {
  return _impl_.reuploadresult_.Get(index);
}
inline const ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult& Message_RequestMediaUploadResponseMessage::reuploadresult(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
  return _internal_reuploadresult(index);
}
inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::_internal_add_reuploadresult() {
  return _impl_.reuploadresult_.Add();
}
inline ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* Message_RequestMediaUploadResponseMessage::add_reuploadresult() {
  ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult* _add = _internal_add_reuploadresult();
  // @@protoc_insertion_point(field_add:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Message_RequestMediaUploadResponseMessage_RequestMediaUploadResult >&
Message_RequestMediaUploadResponseMessage::reuploadresult() const {
  // @@protoc_insertion_point(field_list:proto.Message.RequestMediaUploadResponseMessage.reuploadResult)
  return _impl_.reuploadresult_;
}

// -------------------------------------------------------------------

// Message_RequestPaymentMessage

// optional .proto.Message noteMessage = 4;
inline bool Message_RequestPaymentMessage::_internal_has_notemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr);
  return value;
}
inline bool Message_RequestPaymentMessage::has_notemessage() const {
  return _internal_has_notemessage();
}
inline void Message_RequestPaymentMessage::clear_notemessage() {
  if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message& Message_RequestPaymentMessage::_internal_notemessage() const {
  const ::proto::Message* p = _impl_.notemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& Message_RequestPaymentMessage::notemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.noteMessage)
  return _internal_notemessage();
}
inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_notemessage(
    ::proto::Message* notemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_);
  }
  _impl_.notemessage_ = notemessage;
  if (notemessage) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.noteMessage)
}
inline ::proto::Message* Message_RequestPaymentMessage::release_notemessage() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.notemessage_;
  _impl_.notemessage_ = 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 ::proto::Message* Message_RequestPaymentMessage::unsafe_arena_release_notemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.noteMessage)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.notemessage_;
  _impl_.notemessage_ = nullptr;
  return temp;
}
inline ::proto::Message* Message_RequestPaymentMessage::_internal_mutable_notemessage() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.notemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.notemessage_ = p;
  }
  return _impl_.notemessage_;
}
inline ::proto::Message* Message_RequestPaymentMessage::mutable_notemessage() {
  ::proto::Message* _msg = _internal_mutable_notemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.noteMessage)
  return _msg;
}
inline void Message_RequestPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.notemessage_;
  }
  if (notemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage);
    if (message_arena != submessage_arena) {
      notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, notemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.notemessage_ = notemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.noteMessage)
}

// optional string currencyCodeIso4217 = 1;
inline bool Message_RequestPaymentMessage::_internal_has_currencycodeiso4217() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_RequestPaymentMessage::has_currencycodeiso4217() const {
  return _internal_has_currencycodeiso4217();
}
inline void Message_RequestPaymentMessage::clear_currencycodeiso4217() {
  _impl_.currencycodeiso4217_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_RequestPaymentMessage::currencycodeiso4217() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
  return _internal_currencycodeiso4217();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_RequestPaymentMessage::set_currencycodeiso4217(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.currencycodeiso4217_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
}
inline std::string* Message_RequestPaymentMessage::mutable_currencycodeiso4217() {
  std::string* _s = _internal_mutable_currencycodeiso4217();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
  return _s;
}
inline const std::string& Message_RequestPaymentMessage::_internal_currencycodeiso4217() const {
  return _impl_.currencycodeiso4217_.Get();
}
inline void Message_RequestPaymentMessage::_internal_set_currencycodeiso4217(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.currencycodeiso4217_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_RequestPaymentMessage::_internal_mutable_currencycodeiso4217() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.currencycodeiso4217_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_RequestPaymentMessage::release_currencycodeiso4217() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
  if (!_internal_has_currencycodeiso4217()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.currencycodeiso4217_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycodeiso4217_.IsDefault()) {
    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_RequestPaymentMessage::set_allocated_currencycodeiso4217(std::string* currencycodeiso4217) {
  if (currencycodeiso4217 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.currencycodeiso4217_.SetAllocated(currencycodeiso4217, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycodeiso4217_.IsDefault()) {
    _impl_.currencycodeiso4217_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.currencyCodeIso4217)
}

// optional uint64 amount1000 = 2;
inline bool Message_RequestPaymentMessage::_internal_has_amount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_RequestPaymentMessage::has_amount1000() const {
  return _internal_has_amount1000();
}
inline void Message_RequestPaymentMessage::clear_amount1000() {
  _impl_.amount1000_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t Message_RequestPaymentMessage::_internal_amount1000() const {
  return _impl_.amount1000_;
}
inline uint64_t Message_RequestPaymentMessage::amount1000() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount1000)
  return _internal_amount1000();
}
inline void Message_RequestPaymentMessage::_internal_set_amount1000(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.amount1000_ = value;
}
inline void Message_RequestPaymentMessage::set_amount1000(uint64_t value) {
  _internal_set_amount1000(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.amount1000)
}

// optional string requestFrom = 3;
inline bool Message_RequestPaymentMessage::_internal_has_requestfrom() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_RequestPaymentMessage::has_requestfrom() const {
  return _internal_has_requestfrom();
}
inline void Message_RequestPaymentMessage::clear_requestfrom() {
  _impl_.requestfrom_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_RequestPaymentMessage::requestfrom() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.requestFrom)
  return _internal_requestfrom();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_RequestPaymentMessage::set_requestfrom(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.requestfrom_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.requestFrom)
}
inline std::string* Message_RequestPaymentMessage::mutable_requestfrom() {
  std::string* _s = _internal_mutable_requestfrom();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.requestFrom)
  return _s;
}
inline const std::string& Message_RequestPaymentMessage::_internal_requestfrom() const {
  return _impl_.requestfrom_.Get();
}
inline void Message_RequestPaymentMessage::_internal_set_requestfrom(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.requestfrom_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_RequestPaymentMessage::_internal_mutable_requestfrom() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.requestfrom_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_RequestPaymentMessage::release_requestfrom() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.requestFrom)
  if (!_internal_has_requestfrom()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.requestfrom_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.requestfrom_.IsDefault()) {
    _impl_.requestfrom_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_RequestPaymentMessage::set_allocated_requestfrom(std::string* requestfrom) {
  if (requestfrom != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.requestfrom_.SetAllocated(requestfrom, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.requestfrom_.IsDefault()) {
    _impl_.requestfrom_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.requestFrom)
}

// optional int64 expiryTimestamp = 5;
inline bool Message_RequestPaymentMessage::_internal_has_expirytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_RequestPaymentMessage::has_expirytimestamp() const {
  return _internal_has_expirytimestamp();
}
inline void Message_RequestPaymentMessage::clear_expirytimestamp() {
  _impl_.expirytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline int64_t Message_RequestPaymentMessage::_internal_expirytimestamp() const {
  return _impl_.expirytimestamp_;
}
inline int64_t Message_RequestPaymentMessage::expirytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.expiryTimestamp)
  return _internal_expirytimestamp();
}
inline void Message_RequestPaymentMessage::_internal_set_expirytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.expirytimestamp_ = value;
}
inline void Message_RequestPaymentMessage::set_expirytimestamp(int64_t value) {
  _internal_set_expirytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.RequestPaymentMessage.expiryTimestamp)
}

// optional .proto.Money amount = 6;
inline bool Message_RequestPaymentMessage::_internal_has_amount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.amount_ != nullptr);
  return value;
}
inline bool Message_RequestPaymentMessage::has_amount() const {
  return _internal_has_amount();
}
inline void Message_RequestPaymentMessage::clear_amount() {
  if (_impl_.amount_ != nullptr) _impl_.amount_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::Money& Message_RequestPaymentMessage::_internal_amount() const {
  const ::proto::Money* p = _impl_.amount_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
      ::proto::_Money_default_instance_);
}
inline const ::proto::Money& Message_RequestPaymentMessage::amount() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.amount)
  return _internal_amount();
}
inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_amount(
    ::proto::Money* amount) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.amount_);
  }
  _impl_.amount_ = amount;
  if (amount) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.amount)
}
inline ::proto::Money* Message_RequestPaymentMessage::release_amount() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Money* temp = _impl_.amount_;
  _impl_.amount_ = 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 ::proto::Money* Message_RequestPaymentMessage::unsafe_arena_release_amount() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.amount)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Money* temp = _impl_.amount_;
  _impl_.amount_ = nullptr;
  return temp;
}
inline ::proto::Money* Message_RequestPaymentMessage::_internal_mutable_amount() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.amount_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
    _impl_.amount_ = p;
  }
  return _impl_.amount_;
}
inline ::proto::Money* Message_RequestPaymentMessage::mutable_amount() {
  ::proto::Money* _msg = _internal_mutable_amount();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.amount)
  return _msg;
}
inline void Message_RequestPaymentMessage::set_allocated_amount(::proto::Money* amount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.amount_;
  }
  if (amount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(amount);
    if (message_arena != submessage_arena) {
      amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, amount, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.amount_ = amount;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.amount)
}

// optional .proto.PaymentBackground background = 7;
inline bool Message_RequestPaymentMessage::_internal_has_background() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr);
  return value;
}
inline bool Message_RequestPaymentMessage::has_background() const {
  return _internal_has_background();
}
inline void Message_RequestPaymentMessage::clear_background() {
  if (_impl_.background_ != nullptr) _impl_.background_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::_internal_background() const {
  const ::proto::PaymentBackground* p = _impl_.background_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground&>(
      ::proto::_PaymentBackground_default_instance_);
}
inline const ::proto::PaymentBackground& Message_RequestPaymentMessage::background() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPaymentMessage.background)
  return _internal_background();
}
inline void Message_RequestPaymentMessage::unsafe_arena_set_allocated_background(
    ::proto::PaymentBackground* background) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_);
  }
  _impl_.background_ = background;
  if (background) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPaymentMessage.background)
}
inline ::proto::PaymentBackground* Message_RequestPaymentMessage::release_background() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::PaymentBackground* temp = _impl_.background_;
  _impl_.background_ = 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 ::proto::PaymentBackground* Message_RequestPaymentMessage::unsafe_arena_release_background() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPaymentMessage.background)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::PaymentBackground* temp = _impl_.background_;
  _impl_.background_ = nullptr;
  return temp;
}
inline ::proto::PaymentBackground* Message_RequestPaymentMessage::_internal_mutable_background() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.background_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation());
    _impl_.background_ = p;
  }
  return _impl_.background_;
}
inline ::proto::PaymentBackground* Message_RequestPaymentMessage::mutable_background() {
  ::proto::PaymentBackground* _msg = _internal_mutable_background();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPaymentMessage.background)
  return _msg;
}
inline void Message_RequestPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.background_;
  }
  if (background) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background);
    if (message_arena != submessage_arena) {
      background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, background, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.background_ = background;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPaymentMessage.background)
}

// -------------------------------------------------------------------

// Message_RequestPhoneNumberMessage

// optional .proto.ContextInfo contextInfo = 1;
inline bool Message_RequestPhoneNumberMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_RequestPhoneNumberMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_RequestPhoneNumberMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_RequestPhoneNumberMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.RequestPhoneNumberMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_RequestPhoneNumberMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_RequestPhoneNumberMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.RequestPhoneNumberMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_RequestPhoneNumberMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.RequestPhoneNumberMessage.contextInfo)
  return _msg;
}
inline void Message_RequestPhoneNumberMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.RequestPhoneNumberMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_SendPaymentMessage

// optional .proto.Message noteMessage = 2;
inline bool Message_SendPaymentMessage::_internal_has_notemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.notemessage_ != nullptr);
  return value;
}
inline bool Message_SendPaymentMessage::has_notemessage() const {
  return _internal_has_notemessage();
}
inline void Message_SendPaymentMessage::clear_notemessage() {
  if (_impl_.notemessage_ != nullptr) _impl_.notemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message& Message_SendPaymentMessage::_internal_notemessage() const {
  const ::proto::Message* p = _impl_.notemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& Message_SendPaymentMessage::notemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.noteMessage)
  return _internal_notemessage();
}
inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_notemessage(
    ::proto::Message* notemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.notemessage_);
  }
  _impl_.notemessage_ = notemessage;
  if (notemessage) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.noteMessage)
}
inline ::proto::Message* Message_SendPaymentMessage::release_notemessage() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message* temp = _impl_.notemessage_;
  _impl_.notemessage_ = 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 ::proto::Message* Message_SendPaymentMessage::unsafe_arena_release_notemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.noteMessage)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message* temp = _impl_.notemessage_;
  _impl_.notemessage_ = nullptr;
  return temp;
}
inline ::proto::Message* Message_SendPaymentMessage::_internal_mutable_notemessage() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.notemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.notemessage_ = p;
  }
  return _impl_.notemessage_;
}
inline ::proto::Message* Message_SendPaymentMessage::mutable_notemessage() {
  ::proto::Message* _msg = _internal_mutable_notemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.noteMessage)
  return _msg;
}
inline void Message_SendPaymentMessage::set_allocated_notemessage(::proto::Message* notemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.notemessage_;
  }
  if (notemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(notemessage);
    if (message_arena != submessage_arena) {
      notemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, notemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.notemessage_ = notemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.noteMessage)
}

// optional .proto.MessageKey requestMessageKey = 3;
inline bool Message_SendPaymentMessage::_internal_has_requestmessagekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr);
  return value;
}
inline bool Message_SendPaymentMessage::has_requestmessagekey() const {
  return _internal_has_requestmessagekey();
}
inline void Message_SendPaymentMessage::clear_requestmessagekey() {
  if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::MessageKey& Message_SendPaymentMessage::_internal_requestmessagekey() const {
  const ::proto::MessageKey* p = _impl_.requestmessagekey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Message_SendPaymentMessage::requestmessagekey() const {
  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.requestMessageKey)
  return _internal_requestmessagekey();
}
inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_requestmessagekey(
    ::proto::MessageKey* requestmessagekey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_);
  }
  _impl_.requestmessagekey_ = requestmessagekey;
  if (requestmessagekey) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey)
}
inline ::proto::MessageKey* Message_SendPaymentMessage::release_requestmessagekey() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
  _impl_.requestmessagekey_ = 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 ::proto::MessageKey* Message_SendPaymentMessage::unsafe_arena_release_requestmessagekey() {
  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.requestMessageKey)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
  _impl_.requestmessagekey_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Message_SendPaymentMessage::_internal_mutable_requestmessagekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.requestmessagekey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.requestmessagekey_ = p;
  }
  return _impl_.requestmessagekey_;
}
inline ::proto::MessageKey* Message_SendPaymentMessage::mutable_requestmessagekey() {
  ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey();
  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.requestMessageKey)
  return _msg;
}
inline void Message_SendPaymentMessage::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestmessagekey_;
  }
  if (requestmessagekey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey);
    if (message_arena != submessage_arena) {
      requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestmessagekey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.requestmessagekey_ = requestmessagekey;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.requestMessageKey)
}

// optional .proto.PaymentBackground background = 4;
inline bool Message_SendPaymentMessage::_internal_has_background() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.background_ != nullptr);
  return value;
}
inline bool Message_SendPaymentMessage::has_background() const {
  return _internal_has_background();
}
inline void Message_SendPaymentMessage::clear_background() {
  if (_impl_.background_ != nullptr) _impl_.background_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::PaymentBackground& Message_SendPaymentMessage::_internal_background() const {
  const ::proto::PaymentBackground* p = _impl_.background_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground&>(
      ::proto::_PaymentBackground_default_instance_);
}
inline const ::proto::PaymentBackground& Message_SendPaymentMessage::background() const {
  // @@protoc_insertion_point(field_get:proto.Message.SendPaymentMessage.background)
  return _internal_background();
}
inline void Message_SendPaymentMessage::unsafe_arena_set_allocated_background(
    ::proto::PaymentBackground* background) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_);
  }
  _impl_.background_ = background;
  if (background) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.SendPaymentMessage.background)
}
inline ::proto::PaymentBackground* Message_SendPaymentMessage::release_background() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::PaymentBackground* temp = _impl_.background_;
  _impl_.background_ = 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 ::proto::PaymentBackground* Message_SendPaymentMessage::unsafe_arena_release_background() {
  // @@protoc_insertion_point(field_release:proto.Message.SendPaymentMessage.background)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::PaymentBackground* temp = _impl_.background_;
  _impl_.background_ = nullptr;
  return temp;
}
inline ::proto::PaymentBackground* Message_SendPaymentMessage::_internal_mutable_background() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.background_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PaymentBackground>(GetArenaForAllocation());
    _impl_.background_ = p;
  }
  return _impl_.background_;
}
inline ::proto::PaymentBackground* Message_SendPaymentMessage::mutable_background() {
  ::proto::PaymentBackground* _msg = _internal_mutable_background();
  // @@protoc_insertion_point(field_mutable:proto.Message.SendPaymentMessage.background)
  return _msg;
}
inline void Message_SendPaymentMessage::set_allocated_background(::proto::PaymentBackground* background) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.background_;
  }
  if (background) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background);
    if (message_arena != submessage_arena) {
      background = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, background, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.background_ = background;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.SendPaymentMessage.background)
}

// -------------------------------------------------------------------

// Message_SenderKeyDistributionMessage

// optional string groupId = 1;
inline bool Message_SenderKeyDistributionMessage::_internal_has_groupid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_SenderKeyDistributionMessage::has_groupid() const {
  return _internal_has_groupid();
}
inline void Message_SenderKeyDistributionMessage::clear_groupid() {
  _impl_.groupid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_SenderKeyDistributionMessage::groupid() const {
  // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.groupId)
  return _internal_groupid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_SenderKeyDistributionMessage::set_groupid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.groupid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.groupId)
}
inline std::string* Message_SenderKeyDistributionMessage::mutable_groupid() {
  std::string* _s = _internal_mutable_groupid();
  // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.groupId)
  return _s;
}
inline const std::string& Message_SenderKeyDistributionMessage::_internal_groupid() const {
  return _impl_.groupid_.Get();
}
inline void Message_SenderKeyDistributionMessage::_internal_set_groupid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_groupid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.groupid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_SenderKeyDistributionMessage::release_groupid() {
  // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.groupId)
  if (!_internal_has_groupid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.groupid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupid_.IsDefault()) {
    _impl_.groupid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_SenderKeyDistributionMessage::set_allocated_groupid(std::string* groupid) {
  if (groupid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.groupid_.SetAllocated(groupid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupid_.IsDefault()) {
    _impl_.groupid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.groupId)
}

// optional bytes axolotlSenderKeyDistributionMessage = 2;
inline bool Message_SenderKeyDistributionMessage::_internal_has_axolotlsenderkeydistributionmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_SenderKeyDistributionMessage::has_axolotlsenderkeydistributionmessage() const {
  return _internal_has_axolotlsenderkeydistributionmessage();
}
inline void Message_SenderKeyDistributionMessage::clear_axolotlsenderkeydistributionmessage() {
  _impl_.axolotlsenderkeydistributionmessage_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_SenderKeyDistributionMessage::axolotlsenderkeydistributionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
  return _internal_axolotlsenderkeydistributionmessage();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_SenderKeyDistributionMessage::set_axolotlsenderkeydistributionmessage(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.axolotlsenderkeydistributionmessage_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
}
inline std::string* Message_SenderKeyDistributionMessage::mutable_axolotlsenderkeydistributionmessage() {
  std::string* _s = _internal_mutable_axolotlsenderkeydistributionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
  return _s;
}
inline const std::string& Message_SenderKeyDistributionMessage::_internal_axolotlsenderkeydistributionmessage() const {
  return _impl_.axolotlsenderkeydistributionmessage_.Get();
}
inline void Message_SenderKeyDistributionMessage::_internal_set_axolotlsenderkeydistributionmessage(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.axolotlsenderkeydistributionmessage_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_SenderKeyDistributionMessage::_internal_mutable_axolotlsenderkeydistributionmessage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.axolotlsenderkeydistributionmessage_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_SenderKeyDistributionMessage::release_axolotlsenderkeydistributionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
  if (!_internal_has_axolotlsenderkeydistributionmessage()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.axolotlsenderkeydistributionmessage_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) {
    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_SenderKeyDistributionMessage::set_allocated_axolotlsenderkeydistributionmessage(std::string* axolotlsenderkeydistributionmessage) {
  if (axolotlsenderkeydistributionmessage != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.axolotlsenderkeydistributionmessage_.SetAllocated(axolotlsenderkeydistributionmessage, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.axolotlsenderkeydistributionmessage_.IsDefault()) {
    _impl_.axolotlsenderkeydistributionmessage_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.SenderKeyDistributionMessage.axolotlSenderKeyDistributionMessage)
}

// -------------------------------------------------------------------

// Message_StickerMessage

// optional string url = 1;
inline bool Message_StickerMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_StickerMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_StickerMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::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:proto.Message.StickerMessage.url)
}
inline std::string* Message_StickerMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.url)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_StickerMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.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 Message_StickerMessage::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:proto.Message.StickerMessage.url)
}

// optional bytes fileSha256 = 2;
inline bool Message_StickerMessage::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_StickerMessage::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_StickerMessage::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileSha256)
}
inline std::string* Message_StickerMessage::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileSha256)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_StickerMessage::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileSha256)
}

// optional bytes fileEncSha256 = 3;
inline bool Message_StickerMessage::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_StickerMessage::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_StickerMessage::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileEncSha256)
}
inline std::string* Message_StickerMessage::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.fileEncSha256)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_StickerMessage::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.fileEncSha256)
}

// optional bytes mediaKey = 4;
inline bool Message_StickerMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_StickerMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_StickerMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKey)
}
inline std::string* Message_StickerMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mediaKey)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_StickerMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mediaKey)
}

// optional string mimetype = 5;
inline bool Message_StickerMessage::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void Message_StickerMessage::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_StickerMessage::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mimetype)
}
inline std::string* Message_StickerMessage::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.mimetype)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void Message_StickerMessage::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.mimetype)
}

// optional uint32 height = 6;
inline bool Message_StickerMessage::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_height() const {
  return _internal_has_height();
}
inline void Message_StickerMessage::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t Message_StickerMessage::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t Message_StickerMessage::height() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.height)
  return _internal_height();
}
inline void Message_StickerMessage::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.height_ = value;
}
inline void Message_StickerMessage::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.height)
}

// optional uint32 width = 7;
inline bool Message_StickerMessage::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_width() const {
  return _internal_has_width();
}
inline void Message_StickerMessage::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t Message_StickerMessage::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t Message_StickerMessage::width() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.width)
  return _internal_width();
}
inline void Message_StickerMessage::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.width_ = value;
}
inline void Message_StickerMessage::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.width)
}

// optional string directPath = 8;
inline bool Message_StickerMessage::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_StickerMessage::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_StickerMessage::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.directPath)
}
inline std::string* Message_StickerMessage::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.directPath)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_StickerMessage::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.directPath)
}

// optional uint64 fileLength = 9;
inline bool Message_StickerMessage::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_StickerMessage::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint64_t Message_StickerMessage::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_StickerMessage::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.fileLength)
  return _internal_filelength();
}
inline void Message_StickerMessage::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.filelength_ = value;
}
inline void Message_StickerMessage::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.fileLength)
}

// optional int64 mediaKeyTimestamp = 10;
inline bool Message_StickerMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_StickerMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline int64_t Message_StickerMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_StickerMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_StickerMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_StickerMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.mediaKeyTimestamp)
}

// optional uint32 firstFrameLength = 11;
inline bool Message_StickerMessage::_internal_has_firstframelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_firstframelength() const {
  return _internal_has_firstframelength();
}
inline void Message_StickerMessage::clear_firstframelength() {
  _impl_.firstframelength_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t Message_StickerMessage::_internal_firstframelength() const {
  return _impl_.firstframelength_;
}
inline uint32_t Message_StickerMessage::firstframelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameLength)
  return _internal_firstframelength();
}
inline void Message_StickerMessage::_internal_set_firstframelength(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.firstframelength_ = value;
}
inline void Message_StickerMessage::set_firstframelength(uint32_t value) {
  _internal_set_firstframelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameLength)
}

// optional bytes firstFrameSidecar = 12;
inline bool Message_StickerMessage::_internal_has_firstframesidecar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_firstframesidecar() const {
  return _internal_has_firstframesidecar();
}
inline void Message_StickerMessage::clear_firstframesidecar() {
  _impl_.firstframesidecar_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_StickerMessage::firstframesidecar() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.firstFrameSidecar)
  return _internal_firstframesidecar();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_firstframesidecar(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.firstframesidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.firstFrameSidecar)
}
inline std::string* Message_StickerMessage::mutable_firstframesidecar() {
  std::string* _s = _internal_mutable_firstframesidecar();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.firstFrameSidecar)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_firstframesidecar() const {
  return _impl_.firstframesidecar_.Get();
}
inline void Message_StickerMessage::_internal_set_firstframesidecar(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.firstframesidecar_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_firstframesidecar() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.firstframesidecar_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_firstframesidecar() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.firstFrameSidecar)
  if (!_internal_has_firstframesidecar()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.firstframesidecar_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstframesidecar_.IsDefault()) {
    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_firstframesidecar(std::string* firstframesidecar) {
  if (firstframesidecar != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.firstframesidecar_.SetAllocated(firstframesidecar, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstframesidecar_.IsDefault()) {
    _impl_.firstframesidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.firstFrameSidecar)
}

// optional bool isAnimated = 13;
inline bool Message_StickerMessage::_internal_has_isanimated() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_isanimated() const {
  return _internal_has_isanimated();
}
inline void Message_StickerMessage::clear_isanimated() {
  _impl_.isanimated_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool Message_StickerMessage::_internal_isanimated() const {
  return _impl_.isanimated_;
}
inline bool Message_StickerMessage::isanimated() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.isAnimated)
  return _internal_isanimated();
}
inline void Message_StickerMessage::_internal_set_isanimated(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.isanimated_ = value;
}
inline void Message_StickerMessage::set_isanimated(bool value) {
  _internal_set_isanimated(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.isAnimated)
}

// optional bytes pngThumbnail = 16;
inline bool Message_StickerMessage::_internal_has_pngthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_StickerMessage::has_pngthumbnail() const {
  return _internal_has_pngthumbnail();
}
inline void Message_StickerMessage::clear_pngthumbnail() {
  _impl_.pngthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_StickerMessage::pngthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.pngThumbnail)
  return _internal_pngthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerMessage::set_pngthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.pngthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerMessage.pngThumbnail)
}
inline std::string* Message_StickerMessage::mutable_pngthumbnail() {
  std::string* _s = _internal_mutable_pngthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.pngThumbnail)
  return _s;
}
inline const std::string& Message_StickerMessage::_internal_pngthumbnail() const {
  return _impl_.pngthumbnail_.Get();
}
inline void Message_StickerMessage::_internal_set_pngthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.pngthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::_internal_mutable_pngthumbnail() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.pngthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerMessage::release_pngthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.pngThumbnail)
  if (!_internal_has_pngthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.pngthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pngthumbnail_.IsDefault()) {
    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerMessage::set_allocated_pngthumbnail(std::string* pngthumbnail) {
  if (pngthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.pngthumbnail_.SetAllocated(pngthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pngthumbnail_.IsDefault()) {
    _impl_.pngthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.pngThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_StickerMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_StickerMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_StickerMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::ContextInfo& Message_StickerMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_StickerMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_StickerMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.StickerMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_StickerMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_StickerMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_StickerMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_StickerMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerMessage.contextInfo)
  return _msg;
}
inline void Message_StickerMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerMessage.contextInfo)
}

// -------------------------------------------------------------------

// Message_StickerSyncRMRMessage

// repeated string filehash = 1;
inline int Message_StickerSyncRMRMessage::_internal_filehash_size() const {
  return _impl_.filehash_.size();
}
inline int Message_StickerSyncRMRMessage::filehash_size() const {
  return _internal_filehash_size();
}
inline void Message_StickerSyncRMRMessage::clear_filehash() {
  _impl_.filehash_.Clear();
}
inline std::string* Message_StickerSyncRMRMessage::add_filehash() {
  std::string* _s = _internal_add_filehash();
  // @@protoc_insertion_point(field_add_mutable:proto.Message.StickerSyncRMRMessage.filehash)
  return _s;
}
inline const std::string& Message_StickerSyncRMRMessage::_internal_filehash(int index) const {
  return _impl_.filehash_.Get(index);
}
inline const std::string& Message_StickerSyncRMRMessage::filehash(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.filehash)
  return _internal_filehash(index);
}
inline std::string* Message_StickerSyncRMRMessage::mutable_filehash(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.filehash)
  return _impl_.filehash_.Mutable(index);
}
inline void Message_StickerSyncRMRMessage::set_filehash(int index, const std::string& value) {
  _impl_.filehash_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::set_filehash(int index, std::string&& value) {
  _impl_.filehash_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.filehash_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::set_filehash(int index, const char* value, size_t size) {
  _impl_.filehash_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.Message.StickerSyncRMRMessage.filehash)
}
inline std::string* Message_StickerSyncRMRMessage::_internal_add_filehash() {
  return _impl_.filehash_.Add();
}
inline void Message_StickerSyncRMRMessage::add_filehash(const std::string& value) {
  _impl_.filehash_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::add_filehash(std::string&& value) {
  _impl_.filehash_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::add_filehash(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.filehash_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.Message.StickerSyncRMRMessage.filehash)
}
inline void Message_StickerSyncRMRMessage::add_filehash(const char* value, size_t size) {
  _impl_.filehash_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.Message.StickerSyncRMRMessage.filehash)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Message_StickerSyncRMRMessage::filehash() const {
  // @@protoc_insertion_point(field_list:proto.Message.StickerSyncRMRMessage.filehash)
  return _impl_.filehash_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Message_StickerSyncRMRMessage::mutable_filehash() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.StickerSyncRMRMessage.filehash)
  return &_impl_.filehash_;
}

// optional string rmrSource = 2;
inline bool Message_StickerSyncRMRMessage::_internal_has_rmrsource() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_StickerSyncRMRMessage::has_rmrsource() const {
  return _internal_has_rmrsource();
}
inline void Message_StickerSyncRMRMessage::clear_rmrsource() {
  _impl_.rmrsource_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_StickerSyncRMRMessage::rmrsource() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.rmrSource)
  return _internal_rmrsource();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_StickerSyncRMRMessage::set_rmrsource(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.rmrsource_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.rmrSource)
}
inline std::string* Message_StickerSyncRMRMessage::mutable_rmrsource() {
  std::string* _s = _internal_mutable_rmrsource();
  // @@protoc_insertion_point(field_mutable:proto.Message.StickerSyncRMRMessage.rmrSource)
  return _s;
}
inline const std::string& Message_StickerSyncRMRMessage::_internal_rmrsource() const {
  return _impl_.rmrsource_.Get();
}
inline void Message_StickerSyncRMRMessage::_internal_set_rmrsource(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.rmrsource_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_StickerSyncRMRMessage::_internal_mutable_rmrsource() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.rmrsource_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_StickerSyncRMRMessage::release_rmrsource() {
  // @@protoc_insertion_point(field_release:proto.Message.StickerSyncRMRMessage.rmrSource)
  if (!_internal_has_rmrsource()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.rmrsource_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rmrsource_.IsDefault()) {
    _impl_.rmrsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_StickerSyncRMRMessage::set_allocated_rmrsource(std::string* rmrsource) {
  if (rmrsource != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.rmrsource_.SetAllocated(rmrsource, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rmrsource_.IsDefault()) {
    _impl_.rmrsource_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.StickerSyncRMRMessage.rmrSource)
}

// optional int64 requestTimestamp = 3;
inline bool Message_StickerSyncRMRMessage::_internal_has_requesttimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_StickerSyncRMRMessage::has_requesttimestamp() const {
  return _internal_has_requesttimestamp();
}
inline void Message_StickerSyncRMRMessage::clear_requesttimestamp() {
  _impl_.requesttimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Message_StickerSyncRMRMessage::_internal_requesttimestamp() const {
  return _impl_.requesttimestamp_;
}
inline int64_t Message_StickerSyncRMRMessage::requesttimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.StickerSyncRMRMessage.requestTimestamp)
  return _internal_requesttimestamp();
}
inline void Message_StickerSyncRMRMessage::_internal_set_requesttimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.requesttimestamp_ = value;
}
inline void Message_StickerSyncRMRMessage::set_requesttimestamp(int64_t value) {
  _internal_set_requesttimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.StickerSyncRMRMessage.requestTimestamp)
}

// -------------------------------------------------------------------

// Message_TemplateButtonReplyMessage

// optional string selectedId = 1;
inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_TemplateButtonReplyMessage::has_selectedid() const {
  return _internal_has_selectedid();
}
inline void Message_TemplateButtonReplyMessage::clear_selectedid() {
  _impl_.selectedid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_TemplateButtonReplyMessage::selectedid() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedId)
  return _internal_selectedid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_TemplateButtonReplyMessage::set_selectedid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.selectedid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedId)
}
inline std::string* Message_TemplateButtonReplyMessage::mutable_selectedid() {
  std::string* _s = _internal_mutable_selectedid();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedId)
  return _s;
}
inline const std::string& Message_TemplateButtonReplyMessage::_internal_selectedid() const {
  return _impl_.selectedid_.Get();
}
inline void Message_TemplateButtonReplyMessage::_internal_set_selectedid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.selectedid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selectedid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.selectedid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_TemplateButtonReplyMessage::release_selectedid() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedId)
  if (!_internal_has_selectedid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.selectedid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedid_.IsDefault()) {
    _impl_.selectedid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_TemplateButtonReplyMessage::set_allocated_selectedid(std::string* selectedid) {
  if (selectedid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.selectedid_.SetAllocated(selectedid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selectedid_.IsDefault()) {
    _impl_.selectedid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedId)
}

// optional string selectedDisplayText = 2;
inline bool Message_TemplateButtonReplyMessage::_internal_has_selecteddisplaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_TemplateButtonReplyMessage::has_selecteddisplaytext() const {
  return _internal_has_selecteddisplaytext();
}
inline void Message_TemplateButtonReplyMessage::clear_selecteddisplaytext() {
  _impl_.selecteddisplaytext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_TemplateButtonReplyMessage::selecteddisplaytext() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
  return _internal_selecteddisplaytext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_TemplateButtonReplyMessage::set_selecteddisplaytext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.selecteddisplaytext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
}
inline std::string* Message_TemplateButtonReplyMessage::mutable_selecteddisplaytext() {
  std::string* _s = _internal_mutable_selecteddisplaytext();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
  return _s;
}
inline const std::string& Message_TemplateButtonReplyMessage::_internal_selecteddisplaytext() const {
  return _impl_.selecteddisplaytext_.Get();
}
inline void Message_TemplateButtonReplyMessage::_internal_set_selecteddisplaytext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.selecteddisplaytext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateButtonReplyMessage::_internal_mutable_selecteddisplaytext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.selecteddisplaytext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_TemplateButtonReplyMessage::release_selecteddisplaytext() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
  if (!_internal_has_selecteddisplaytext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.selecteddisplaytext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selecteddisplaytext_.IsDefault()) {
    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_TemplateButtonReplyMessage::set_allocated_selecteddisplaytext(std::string* selecteddisplaytext) {
  if (selecteddisplaytext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.selecteddisplaytext_.SetAllocated(selecteddisplaytext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.selecteddisplaytext_.IsDefault()) {
    _impl_.selecteddisplaytext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.selectedDisplayText)
}

// optional .proto.ContextInfo contextInfo = 3;
inline bool Message_TemplateButtonReplyMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_TemplateButtonReplyMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_TemplateButtonReplyMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_TemplateButtonReplyMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_TemplateButtonReplyMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_TemplateButtonReplyMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateButtonReplyMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_TemplateButtonReplyMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateButtonReplyMessage.contextInfo)
  return _msg;
}
inline void Message_TemplateButtonReplyMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateButtonReplyMessage.contextInfo)
}

// optional uint32 selectedIndex = 4;
inline bool Message_TemplateButtonReplyMessage::_internal_has_selectedindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_TemplateButtonReplyMessage::has_selectedindex() const {
  return _internal_has_selectedindex();
}
inline void Message_TemplateButtonReplyMessage::clear_selectedindex() {
  _impl_.selectedindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t Message_TemplateButtonReplyMessage::_internal_selectedindex() const {
  return _impl_.selectedindex_;
}
inline uint32_t Message_TemplateButtonReplyMessage::selectedindex() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateButtonReplyMessage.selectedIndex)
  return _internal_selectedindex();
}
inline void Message_TemplateButtonReplyMessage::_internal_set_selectedindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.selectedindex_ = value;
}
inline void Message_TemplateButtonReplyMessage::set_selectedindex(uint32_t value) {
  _internal_set_selectedindex(value);
  // @@protoc_insertion_point(field_set:proto.Message.TemplateButtonReplyMessage.selectedIndex)
}

// -------------------------------------------------------------------

// Message_TemplateMessage_FourRowTemplate

// optional .proto.Message.HighlyStructuredMessage content = 6;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_content() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.content_ != nullptr);
  return value;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_content() const {
  return _internal_has_content();
}
inline void Message_TemplateMessage_FourRowTemplate::clear_content() {
  if (_impl_.content_ != nullptr) _impl_.content_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_content() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.content_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::content() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.content)
  return _internal_content();
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_content(
    ::proto::Message_HighlyStructuredMessage* content) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.content_);
  }
  _impl_.content_ = content;
  if (content) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content)
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_content() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_;
  _impl_.content_ = 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 ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_content() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.content)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.content_;
  _impl_.content_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_content() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.content_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.content_ = p;
  }
  return _impl_.content_;
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_content() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_content();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.content)
  return _msg;
}
inline void Message_TemplateMessage_FourRowTemplate::set_allocated_content(::proto::Message_HighlyStructuredMessage* content) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.content_;
  }
  if (content) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(content);
    if (message_arena != submessage_arena) {
      content = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, content, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.content_ = content;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.content)
}

// optional .proto.Message.HighlyStructuredMessage footer = 7;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_footer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.footer_ != nullptr);
  return value;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_footer() const {
  return _internal_has_footer();
}
inline void Message_TemplateMessage_FourRowTemplate::clear_footer() {
  if (_impl_.footer_ != nullptr) _impl_.footer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_footer() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.footer_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::footer() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.footer)
  return _internal_footer();
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_footer(
    ::proto::Message_HighlyStructuredMessage* footer) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.footer_);
  }
  _impl_.footer_ = footer;
  if (footer) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer)
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_footer() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_;
  _impl_.footer_ = 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 ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_footer() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.footer)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.footer_;
  _impl_.footer_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_footer() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.footer_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.footer_ = p;
  }
  return _impl_.footer_;
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_footer() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_footer();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.footer)
  return _msg;
}
inline void Message_TemplateMessage_FourRowTemplate::set_allocated_footer(::proto::Message_HighlyStructuredMessage* footer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.footer_;
  }
  if (footer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(footer);
    if (message_arena != submessage_arena) {
      footer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, footer, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.footer_ = footer;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.footer)
}

// repeated .proto.TemplateButton buttons = 8;
inline int Message_TemplateMessage_FourRowTemplate::_internal_buttons_size() const {
  return _impl_.buttons_.size();
}
inline int Message_TemplateMessage_FourRowTemplate::buttons_size() const {
  return _internal_buttons_size();
}
inline void Message_TemplateMessage_FourRowTemplate::clear_buttons() {
  _impl_.buttons_.Clear();
}
inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::mutable_buttons(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.buttons)
  return _impl_.buttons_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >*
Message_TemplateMessage_FourRowTemplate::mutable_buttons() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.FourRowTemplate.buttons)
  return &_impl_.buttons_;
}
inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::_internal_buttons(int index) const {
  return _impl_.buttons_.Get(index);
}
inline const ::proto::TemplateButton& Message_TemplateMessage_FourRowTemplate::buttons(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.buttons)
  return _internal_buttons(index);
}
inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::_internal_add_buttons() {
  return _impl_.buttons_.Add();
}
inline ::proto::TemplateButton* Message_TemplateMessage_FourRowTemplate::add_buttons() {
  ::proto::TemplateButton* _add = _internal_add_buttons();
  // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.FourRowTemplate.buttons)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::TemplateButton >&
Message_TemplateMessage_FourRowTemplate::buttons() const {
  // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.FourRowTemplate.buttons)
  return _impl_.buttons_;
}

// .proto.Message.DocumentMessage documentMessage = 1;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_documentmessage() const {
  return title_case() == kDocumentMessage;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_documentmessage() const {
  return _internal_has_documentmessage();
}
inline void Message_TemplateMessage_FourRowTemplate::set_has_documentmessage() {
  _impl_._oneof_case_[0] = kDocumentMessage;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_documentmessage() {
  if (_internal_has_documentmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.documentmessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::release_documentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_title();
    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::_internal_documentmessage() const {
  return _internal_has_documentmessage()
      ? *_impl_.title_.documentmessage_
      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
}
inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_FourRowTemplate::documentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
  return _internal_documentmessage();
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_documentmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_title();
    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
    _impl_.title_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
  clear_title();
  if (documentmessage) {
    set_has_documentmessage();
    _impl_.title_.documentmessage_ = documentmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_documentmessage() {
  if (!_internal_has_documentmessage()) {
    clear_title();
    set_has_documentmessage();
    _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.documentmessage_;
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_FourRowTemplate::mutable_documentmessage() {
  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.documentMessage)
  return _msg;
}

// .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 2;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_highlystructuredmessage() const {
  return title_case() == kHighlyStructuredMessage;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_highlystructuredmessage() const {
  return _internal_has_highlystructuredmessage();
}
inline void Message_TemplateMessage_FourRowTemplate::set_has_highlystructuredmessage() {
  _impl_._oneof_case_[0] = kHighlyStructuredMessage;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_highlystructuredmessage() {
  if (_internal_has_highlystructuredmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.highlystructuredmessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::release_highlystructuredmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
  if (_internal_has_highlystructuredmessage()) {
    clear_has_title();
    ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.highlystructuredmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::_internal_highlystructuredmessage() const {
  return _internal_has_highlystructuredmessage()
      ? *_impl_.title_.highlystructuredmessage_
      : reinterpret_cast< ::proto::Message_HighlyStructuredMessage&>(::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& Message_TemplateMessage_FourRowTemplate::highlystructuredmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
  return _internal_highlystructuredmessage();
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_highlystructuredmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
  if (_internal_has_highlystructuredmessage()) {
    clear_has_title();
    ::proto::Message_HighlyStructuredMessage* temp = _impl_.title_.highlystructuredmessage_;
    _impl_.title_.highlystructuredmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
  clear_title();
  if (highlystructuredmessage) {
    set_has_highlystructuredmessage();
    _impl_.title_.highlystructuredmessage_ = highlystructuredmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_highlystructuredmessage() {
  if (!_internal_has_highlystructuredmessage()) {
    clear_title();
    set_has_highlystructuredmessage();
    _impl_.title_.highlystructuredmessage_ = CreateMaybeMessage< ::proto::Message_HighlyStructuredMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.highlystructuredmessage_;
}
inline ::proto::Message_HighlyStructuredMessage* Message_TemplateMessage_FourRowTemplate::mutable_highlystructuredmessage() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.highlyStructuredMessage)
  return _msg;
}

// .proto.Message.ImageMessage imageMessage = 3;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_imagemessage() const {
  return title_case() == kImageMessage;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_imagemessage() const {
  return _internal_has_imagemessage();
}
inline void Message_TemplateMessage_FourRowTemplate::set_has_imagemessage() {
  _impl_._oneof_case_[0] = kImageMessage;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_imagemessage() {
  if (_internal_has_imagemessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.imagemessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::release_imagemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_title();
    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::_internal_imagemessage() const {
  return _internal_has_imagemessage()
      ? *_impl_.title_.imagemessage_
      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_TemplateMessage_FourRowTemplate::imagemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
  return _internal_imagemessage();
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_imagemessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_title();
    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
    _impl_.title_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
  clear_title();
  if (imagemessage) {
    set_has_imagemessage();
    _impl_.title_.imagemessage_ = imagemessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_imagemessage() {
  if (!_internal_has_imagemessage()) {
    clear_title();
    set_has_imagemessage();
    _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.imagemessage_;
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_FourRowTemplate::mutable_imagemessage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.imageMessage)
  return _msg;
}

// .proto.Message.VideoMessage videoMessage = 4;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_videomessage() const {
  return title_case() == kVideoMessage;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_videomessage() const {
  return _internal_has_videomessage();
}
inline void Message_TemplateMessage_FourRowTemplate::set_has_videomessage() {
  _impl_._oneof_case_[0] = kVideoMessage;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_videomessage() {
  if (_internal_has_videomessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.videomessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::release_videomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_title();
    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::_internal_videomessage() const {
  return _internal_has_videomessage()
      ? *_impl_.title_.videomessage_
      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
}
inline const ::proto::Message_VideoMessage& Message_TemplateMessage_FourRowTemplate::videomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
  return _internal_videomessage();
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_videomessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_title();
    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
    _impl_.title_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
  clear_title();
  if (videomessage) {
    set_has_videomessage();
    _impl_.title_.videomessage_ = videomessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_videomessage() {
  if (!_internal_has_videomessage()) {
    clear_title();
    set_has_videomessage();
    _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.videomessage_;
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_FourRowTemplate::mutable_videomessage() {
  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.videoMessage)
  return _msg;
}

// .proto.Message.LocationMessage locationMessage = 5;
inline bool Message_TemplateMessage_FourRowTemplate::_internal_has_locationmessage() const {
  return title_case() == kLocationMessage;
}
inline bool Message_TemplateMessage_FourRowTemplate::has_locationmessage() const {
  return _internal_has_locationmessage();
}
inline void Message_TemplateMessage_FourRowTemplate::set_has_locationmessage() {
  _impl_._oneof_case_[0] = kLocationMessage;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_locationmessage() {
  if (_internal_has_locationmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.locationmessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::release_locationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_title();
    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::_internal_locationmessage() const {
  return _internal_has_locationmessage()
      ? *_impl_.title_.locationmessage_
      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
}
inline const ::proto::Message_LocationMessage& Message_TemplateMessage_FourRowTemplate::locationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
  return _internal_locationmessage();
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::unsafe_arena_release_locationmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_title();
    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
    _impl_.title_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_FourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
  clear_title();
  if (locationmessage) {
    set_has_locationmessage();
    _impl_.title_.locationmessage_ = locationmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::_internal_mutable_locationmessage() {
  if (!_internal_has_locationmessage()) {
    clear_title();
    set_has_locationmessage();
    _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.locationmessage_;
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_FourRowTemplate::mutable_locationmessage() {
  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.FourRowTemplate.locationMessage)
  return _msg;
}

inline bool Message_TemplateMessage_FourRowTemplate::has_title() const {
  return title_case() != TITLE_NOT_SET;
}
inline void Message_TemplateMessage_FourRowTemplate::clear_has_title() {
  _impl_._oneof_case_[0] = TITLE_NOT_SET;
}
inline Message_TemplateMessage_FourRowTemplate::TitleCase Message_TemplateMessage_FourRowTemplate::title_case() const {
  return Message_TemplateMessage_FourRowTemplate::TitleCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_TemplateMessage_HydratedFourRowTemplate

// optional string hydratedContentText = 6;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedcontenttext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedcontenttext() const {
  return _internal_has_hydratedcontenttext();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedcontenttext() {
  _impl_.hydratedcontenttext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedcontenttext() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
  return _internal_hydratedcontenttext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedcontenttext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.hydratedcontenttext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedcontenttext() {
  std::string* _s = _internal_mutable_hydratedcontenttext();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
  return _s;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedcontenttext() const {
  return _impl_.hydratedcontenttext_.Get();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedcontenttext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.hydratedcontenttext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedcontenttext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.hydratedcontenttext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedcontenttext() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
  if (!_internal_has_hydratedcontenttext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.hydratedcontenttext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hydratedcontenttext_.IsDefault()) {
    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedcontenttext(std::string* hydratedcontenttext) {
  if (hydratedcontenttext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.hydratedcontenttext_.SetAllocated(hydratedcontenttext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hydratedcontenttext_.IsDefault()) {
    _impl_.hydratedcontenttext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedContentText)
}

// optional string hydratedFooterText = 7;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedfootertext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedfootertext() const {
  return _internal_has_hydratedfootertext();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedfootertext() {
  _impl_.hydratedfootertext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedfootertext() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
  return _internal_hydratedfootertext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedfootertext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.hydratedfootertext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedfootertext() {
  std::string* _s = _internal_mutable_hydratedfootertext();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
  return _s;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedfootertext() const {
  return _impl_.hydratedfootertext_.Get();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedfootertext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.hydratedfootertext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedfootertext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.hydratedfootertext_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedfootertext() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
  if (!_internal_has_hydratedfootertext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.hydratedfootertext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hydratedfootertext_.IsDefault()) {
    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedfootertext(std::string* hydratedfootertext) {
  if (hydratedfootertext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.hydratedfootertext_.SetAllocated(hydratedfootertext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hydratedfootertext_.IsDefault()) {
    _impl_.hydratedfootertext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedFooterText)
}

// repeated .proto.HydratedTemplateButton hydratedButtons = 8;
inline int Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons_size() const {
  return _impl_.hydratedbuttons_.size();
}
inline int Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons_size() const {
  return _internal_hydratedbuttons_size();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedbuttons() {
  _impl_.hydratedbuttons_.Clear();
}
inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
  return _impl_.hydratedbuttons_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >*
Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedbuttons() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
  return &_impl_.hydratedbuttons_;
}
inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedbuttons(int index) const {
  return _impl_.hydratedbuttons_.Get(index);
}
inline const ::proto::HydratedTemplateButton& Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
  return _internal_hydratedbuttons(index);
}
inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::_internal_add_hydratedbuttons() {
  return _impl_.hydratedbuttons_.Add();
}
inline ::proto::HydratedTemplateButton* Message_TemplateMessage_HydratedFourRowTemplate::add_hydratedbuttons() {
  ::proto::HydratedTemplateButton* _add = _internal_add_hydratedbuttons();
  // @@protoc_insertion_point(field_add:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::HydratedTemplateButton >&
Message_TemplateMessage_HydratedFourRowTemplate::hydratedbuttons() const {
  // @@protoc_insertion_point(field_list:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedButtons)
  return _impl_.hydratedbuttons_;
}

// optional string templateId = 9;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_templateid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_templateid() const {
  return _internal_has_templateid();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_templateid() {
  _impl_.templateid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::templateid() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
  return _internal_templateid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_TemplateMessage_HydratedFourRowTemplate::set_templateid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.templateid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_templateid() {
  std::string* _s = _internal_mutable_templateid();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
  return _s;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_templateid() const {
  return _impl_.templateid_.Get();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_templateid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.templateid_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_templateid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.templateid_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_templateid() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
  if (!_internal_has_templateid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.templateid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.templateid_.IsDefault()) {
    _impl_.templateid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_templateid(std::string* templateid) {
  if (templateid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.templateid_.SetAllocated(templateid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.templateid_.IsDefault()) {
    _impl_.templateid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.templateId)
}

// .proto.Message.DocumentMessage documentMessage = 1;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_documentmessage() const {
  return title_case() == kDocumentMessage;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_documentmessage() const {
  return _internal_has_documentmessage();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_documentmessage() {
  _impl_._oneof_case_[0] = kDocumentMessage;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_documentmessage() {
  if (_internal_has_documentmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.documentmessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_documentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_title();
    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_documentmessage() const {
  return _internal_has_documentmessage()
      ? *_impl_.title_.documentmessage_
      : reinterpret_cast< ::proto::Message_DocumentMessage&>(::proto::_Message_DocumentMessage_default_instance_);
}
inline const ::proto::Message_DocumentMessage& Message_TemplateMessage_HydratedFourRowTemplate::documentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
  return _internal_documentmessage();
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_documentmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
  if (_internal_has_documentmessage()) {
    clear_has_title();
    ::proto::Message_DocumentMessage* temp = _impl_.title_.documentmessage_;
    _impl_.title_.documentmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
  clear_title();
  if (documentmessage) {
    set_has_documentmessage();
    _impl_.title_.documentmessage_ = documentmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_documentmessage() {
  if (!_internal_has_documentmessage()) {
    clear_title();
    set_has_documentmessage();
    _impl_.title_.documentmessage_ = CreateMaybeMessage< ::proto::Message_DocumentMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.documentmessage_;
}
inline ::proto::Message_DocumentMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_documentmessage() {
  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.documentMessage)
  return _msg;
}

// string hydratedTitleText = 2;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_hydratedtitletext() const {
  return title_case() == kHydratedTitleText;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_hydratedtitletext() const {
  return _internal_has_hydratedtitletext();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_hydratedtitletext() {
  _impl_._oneof_case_[0] = kHydratedTitleText;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_hydratedtitletext() {
  if (_internal_has_hydratedtitletext()) {
    _impl_.title_.hydratedtitletext_.Destroy();
    clear_has_title();
  }
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::hydratedtitletext() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
  return _internal_hydratedtitletext();
}
template <typename ArgT0, typename... ArgT>
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_hydratedtitletext(ArgT0&& arg0, ArgT... args) {
  if (!_internal_has_hydratedtitletext()) {
    clear_title();
    set_has_hydratedtitletext();
    _impl_.title_.hydratedtitletext_.InitDefault();
  }
  _impl_.title_.hydratedtitletext_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::mutable_hydratedtitletext() {
  std::string* _s = _internal_mutable_hydratedtitletext();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
  return _s;
}
inline const std::string& Message_TemplateMessage_HydratedFourRowTemplate::_internal_hydratedtitletext() const {
  if (_internal_has_hydratedtitletext()) {
    return _impl_.title_.hydratedtitletext_.Get();
  }
  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::_internal_set_hydratedtitletext(const std::string& value) {
  if (!_internal_has_hydratedtitletext()) {
    clear_title();
    set_has_hydratedtitletext();
    _impl_.title_.hydratedtitletext_.InitDefault();
  }
  _impl_.title_.hydratedtitletext_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_hydratedtitletext() {
  if (!_internal_has_hydratedtitletext()) {
    clear_title();
    set_has_hydratedtitletext();
    _impl_.title_.hydratedtitletext_.InitDefault();
  }
  return _impl_.title_.hydratedtitletext_.Mutable(      GetArenaForAllocation());
}
inline std::string* Message_TemplateMessage_HydratedFourRowTemplate::release_hydratedtitletext() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
  if (_internal_has_hydratedtitletext()) {
    clear_has_title();
    return _impl_.title_.hydratedtitletext_.Release();
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_allocated_hydratedtitletext(std::string* hydratedtitletext) {
  if (has_title()) {
    clear_title();
  }
  if (hydratedtitletext != nullptr) {
    set_has_hydratedtitletext();
    _impl_.title_.hydratedtitletext_.InitAllocated(hydratedtitletext, GetArenaForAllocation());
  }
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.hydratedTitleText)
}

// .proto.Message.ImageMessage imageMessage = 3;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_imagemessage() const {
  return title_case() == kImageMessage;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_imagemessage() const {
  return _internal_has_imagemessage();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_imagemessage() {
  _impl_._oneof_case_[0] = kImageMessage;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_imagemessage() {
  if (_internal_has_imagemessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.imagemessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_imagemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_title();
    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_imagemessage() const {
  return _internal_has_imagemessage()
      ? *_impl_.title_.imagemessage_
      : reinterpret_cast< ::proto::Message_ImageMessage&>(::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message_TemplateMessage_HydratedFourRowTemplate::imagemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
  return _internal_imagemessage();
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_imagemessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
  if (_internal_has_imagemessage()) {
    clear_has_title();
    ::proto::Message_ImageMessage* temp = _impl_.title_.imagemessage_;
    _impl_.title_.imagemessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
  clear_title();
  if (imagemessage) {
    set_has_imagemessage();
    _impl_.title_.imagemessage_ = imagemessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_imagemessage() {
  if (!_internal_has_imagemessage()) {
    clear_title();
    set_has_imagemessage();
    _impl_.title_.imagemessage_ = CreateMaybeMessage< ::proto::Message_ImageMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.imagemessage_;
}
inline ::proto::Message_ImageMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_imagemessage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.imageMessage)
  return _msg;
}

// .proto.Message.VideoMessage videoMessage = 4;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_videomessage() const {
  return title_case() == kVideoMessage;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_videomessage() const {
  return _internal_has_videomessage();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_videomessage() {
  _impl_._oneof_case_[0] = kVideoMessage;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_videomessage() {
  if (_internal_has_videomessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.videomessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_videomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_title();
    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_videomessage() const {
  return _internal_has_videomessage()
      ? *_impl_.title_.videomessage_
      : reinterpret_cast< ::proto::Message_VideoMessage&>(::proto::_Message_VideoMessage_default_instance_);
}
inline const ::proto::Message_VideoMessage& Message_TemplateMessage_HydratedFourRowTemplate::videomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
  return _internal_videomessage();
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_videomessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
  if (_internal_has_videomessage()) {
    clear_has_title();
    ::proto::Message_VideoMessage* temp = _impl_.title_.videomessage_;
    _impl_.title_.videomessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
  clear_title();
  if (videomessage) {
    set_has_videomessage();
    _impl_.title_.videomessage_ = videomessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_videomessage() {
  if (!_internal_has_videomessage()) {
    clear_title();
    set_has_videomessage();
    _impl_.title_.videomessage_ = CreateMaybeMessage< ::proto::Message_VideoMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.videomessage_;
}
inline ::proto::Message_VideoMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_videomessage() {
  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.videoMessage)
  return _msg;
}

// .proto.Message.LocationMessage locationMessage = 5;
inline bool Message_TemplateMessage_HydratedFourRowTemplate::_internal_has_locationmessage() const {
  return title_case() == kLocationMessage;
}
inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_locationmessage() const {
  return _internal_has_locationmessage();
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::set_has_locationmessage() {
  _impl_._oneof_case_[0] = kLocationMessage;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_locationmessage() {
  if (_internal_has_locationmessage()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.title_.locationmessage_;
    }
    clear_has_title();
  }
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::release_locationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_title();
    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.title_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::_internal_locationmessage() const {
  return _internal_has_locationmessage()
      ? *_impl_.title_.locationmessage_
      : reinterpret_cast< ::proto::Message_LocationMessage&>(::proto::_Message_LocationMessage_default_instance_);
}
inline const ::proto::Message_LocationMessage& Message_TemplateMessage_HydratedFourRowTemplate::locationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
  return _internal_locationmessage();
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_release_locationmessage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
  if (_internal_has_locationmessage()) {
    clear_has_title();
    ::proto::Message_LocationMessage* temp = _impl_.title_.locationmessage_;
    _impl_.title_.locationmessage_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::unsafe_arena_set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
  clear_title();
  if (locationmessage) {
    set_has_locationmessage();
    _impl_.title_.locationmessage_ = locationmessage;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::_internal_mutable_locationmessage() {
  if (!_internal_has_locationmessage()) {
    clear_title();
    set_has_locationmessage();
    _impl_.title_.locationmessage_ = CreateMaybeMessage< ::proto::Message_LocationMessage >(GetArenaForAllocation());
  }
  return _impl_.title_.locationmessage_;
}
inline ::proto::Message_LocationMessage* Message_TemplateMessage_HydratedFourRowTemplate::mutable_locationmessage() {
  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.HydratedFourRowTemplate.locationMessage)
  return _msg;
}

inline bool Message_TemplateMessage_HydratedFourRowTemplate::has_title() const {
  return title_case() != TITLE_NOT_SET;
}
inline void Message_TemplateMessage_HydratedFourRowTemplate::clear_has_title() {
  _impl_._oneof_case_[0] = TITLE_NOT_SET;
}
inline Message_TemplateMessage_HydratedFourRowTemplate::TitleCase Message_TemplateMessage_HydratedFourRowTemplate::title_case() const {
  return Message_TemplateMessage_HydratedFourRowTemplate::TitleCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_TemplateMessage

// optional .proto.ContextInfo contextInfo = 3;
inline bool Message_TemplateMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_TemplateMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_TemplateMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::ContextInfo& Message_TemplateMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_TemplateMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_TemplateMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_TemplateMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_TemplateMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_TemplateMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_TemplateMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.contextInfo)
  return _msg;
}
inline void Message_TemplateMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.contextInfo)
}

// optional .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedTemplate = 4;
inline bool Message_TemplateMessage::_internal_has_hydratedtemplate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.hydratedtemplate_ != nullptr);
  return value;
}
inline bool Message_TemplateMessage::has_hydratedtemplate() const {
  return _internal_has_hydratedtemplate();
}
inline void Message_TemplateMessage::clear_hydratedtemplate() {
  if (_impl_.hydratedtemplate_ != nullptr) _impl_.hydratedtemplate_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedtemplate() const {
  const ::proto::Message_TemplateMessage_HydratedFourRowTemplate* p = _impl_.hydratedtemplate_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(
      ::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
}
inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedtemplate() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedTemplate)
  return _internal_hydratedtemplate();
}
inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedtemplate(
    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hydratedtemplate_);
  }
  _impl_.hydratedtemplate_ = hydratedtemplate;
  if (hydratedtemplate) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedTemplate)
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedtemplate() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_;
  _impl_.hydratedtemplate_ = 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 ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedtemplate() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedTemplate)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.hydratedtemplate_;
  _impl_.hydratedtemplate_ = nullptr;
  return temp;
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedtemplate() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.hydratedtemplate_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage_HydratedFourRowTemplate>(GetArenaForAllocation());
    _impl_.hydratedtemplate_ = p;
  }
  return _impl_.hydratedtemplate_;
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedtemplate() {
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedtemplate();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedTemplate)
  return _msg;
}
inline void Message_TemplateMessage::set_allocated_hydratedtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedtemplate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.hydratedtemplate_;
  }
  if (hydratedtemplate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(hydratedtemplate);
    if (message_arena != submessage_arena) {
      hydratedtemplate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hydratedtemplate, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.hydratedtemplate_ = hydratedtemplate;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.TemplateMessage.hydratedTemplate)
}

// .proto.Message.TemplateMessage.FourRowTemplate fourRowTemplate = 1;
inline bool Message_TemplateMessage::_internal_has_fourrowtemplate() const {
  return format_case() == kFourRowTemplate;
}
inline bool Message_TemplateMessage::has_fourrowtemplate() const {
  return _internal_has_fourrowtemplate();
}
inline void Message_TemplateMessage::set_has_fourrowtemplate() {
  _impl_._oneof_case_[0] = kFourRowTemplate;
}
inline void Message_TemplateMessage::clear_fourrowtemplate() {
  if (_internal_has_fourrowtemplate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.format_.fourrowtemplate_;
    }
    clear_has_format();
  }
}
inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::release_fourrowtemplate() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.fourRowTemplate)
  if (_internal_has_fourrowtemplate()) {
    clear_has_format();
    ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.format_.fourrowtemplate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::_internal_fourrowtemplate() const {
  return _internal_has_fourrowtemplate()
      ? *_impl_.format_.fourrowtemplate_
      : reinterpret_cast< ::proto::Message_TemplateMessage_FourRowTemplate&>(::proto::_Message_TemplateMessage_FourRowTemplate_default_instance_);
}
inline const ::proto::Message_TemplateMessage_FourRowTemplate& Message_TemplateMessage::fourrowtemplate() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.fourRowTemplate)
  return _internal_fourrowtemplate();
}
inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::unsafe_arena_release_fourrowtemplate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.fourRowTemplate)
  if (_internal_has_fourrowtemplate()) {
    clear_has_format();
    ::proto::Message_TemplateMessage_FourRowTemplate* temp = _impl_.format_.fourrowtemplate_;
    _impl_.format_.fourrowtemplate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage::unsafe_arena_set_allocated_fourrowtemplate(::proto::Message_TemplateMessage_FourRowTemplate* fourrowtemplate) {
  clear_format();
  if (fourrowtemplate) {
    set_has_fourrowtemplate();
    _impl_.format_.fourrowtemplate_ = fourrowtemplate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.fourRowTemplate)
}
inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::_internal_mutable_fourrowtemplate() {
  if (!_internal_has_fourrowtemplate()) {
    clear_format();
    set_has_fourrowtemplate();
    _impl_.format_.fourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_FourRowTemplate >(GetArenaForAllocation());
  }
  return _impl_.format_.fourrowtemplate_;
}
inline ::proto::Message_TemplateMessage_FourRowTemplate* Message_TemplateMessage::mutable_fourrowtemplate() {
  ::proto::Message_TemplateMessage_FourRowTemplate* _msg = _internal_mutable_fourrowtemplate();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.fourRowTemplate)
  return _msg;
}

// .proto.Message.TemplateMessage.HydratedFourRowTemplate hydratedFourRowTemplate = 2;
inline bool Message_TemplateMessage::_internal_has_hydratedfourrowtemplate() const {
  return format_case() == kHydratedFourRowTemplate;
}
inline bool Message_TemplateMessage::has_hydratedfourrowtemplate() const {
  return _internal_has_hydratedfourrowtemplate();
}
inline void Message_TemplateMessage::set_has_hydratedfourrowtemplate() {
  _impl_._oneof_case_[0] = kHydratedFourRowTemplate;
}
inline void Message_TemplateMessage::clear_hydratedfourrowtemplate() {
  if (_internal_has_hydratedfourrowtemplate()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.format_.hydratedfourrowtemplate_;
    }
    clear_has_format();
  }
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::release_hydratedfourrowtemplate() {
  // @@protoc_insertion_point(field_release:proto.Message.TemplateMessage.hydratedFourRowTemplate)
  if (_internal_has_hydratedfourrowtemplate()) {
    clear_has_format();
    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.format_.hydratedfourrowtemplate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::_internal_hydratedfourrowtemplate() const {
  return _internal_has_hydratedfourrowtemplate()
      ? *_impl_.format_.hydratedfourrowtemplate_
      : reinterpret_cast< ::proto::Message_TemplateMessage_HydratedFourRowTemplate&>(::proto::_Message_TemplateMessage_HydratedFourRowTemplate_default_instance_);
}
inline const ::proto::Message_TemplateMessage_HydratedFourRowTemplate& Message_TemplateMessage::hydratedfourrowtemplate() const {
  // @@protoc_insertion_point(field_get:proto.Message.TemplateMessage.hydratedFourRowTemplate)
  return _internal_hydratedfourrowtemplate();
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::unsafe_arena_release_hydratedfourrowtemplate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.Message.TemplateMessage.hydratedFourRowTemplate)
  if (_internal_has_hydratedfourrowtemplate()) {
    clear_has_format();
    ::proto::Message_TemplateMessage_HydratedFourRowTemplate* temp = _impl_.format_.hydratedfourrowtemplate_;
    _impl_.format_.hydratedfourrowtemplate_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Message_TemplateMessage::unsafe_arena_set_allocated_hydratedfourrowtemplate(::proto::Message_TemplateMessage_HydratedFourRowTemplate* hydratedfourrowtemplate) {
  clear_format();
  if (hydratedfourrowtemplate) {
    set_has_hydratedfourrowtemplate();
    _impl_.format_.hydratedfourrowtemplate_ = hydratedfourrowtemplate;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.TemplateMessage.hydratedFourRowTemplate)
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::_internal_mutable_hydratedfourrowtemplate() {
  if (!_internal_has_hydratedfourrowtemplate()) {
    clear_format();
    set_has_hydratedfourrowtemplate();
    _impl_.format_.hydratedfourrowtemplate_ = CreateMaybeMessage< ::proto::Message_TemplateMessage_HydratedFourRowTemplate >(GetArenaForAllocation());
  }
  return _impl_.format_.hydratedfourrowtemplate_;
}
inline ::proto::Message_TemplateMessage_HydratedFourRowTemplate* Message_TemplateMessage::mutable_hydratedfourrowtemplate() {
  ::proto::Message_TemplateMessage_HydratedFourRowTemplate* _msg = _internal_mutable_hydratedfourrowtemplate();
  // @@protoc_insertion_point(field_mutable:proto.Message.TemplateMessage.hydratedFourRowTemplate)
  return _msg;
}

inline bool Message_TemplateMessage::has_format() const {
  return format_case() != FORMAT_NOT_SET;
}
inline void Message_TemplateMessage::clear_has_format() {
  _impl_._oneof_case_[0] = FORMAT_NOT_SET;
}
inline Message_TemplateMessage::FormatCase Message_TemplateMessage::format_case() const {
  return Message_TemplateMessage::FormatCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// Message_VideoMessage

// optional string url = 1;
inline bool Message_VideoMessage::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_url() const {
  return _internal_has_url();
}
inline void Message_VideoMessage::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message_VideoMessage::url() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::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:proto.Message.VideoMessage.url)
}
inline std::string* Message_VideoMessage::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.url)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_url() const {
  return _impl_.url_.Get();
}
inline void Message_VideoMessage::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_url() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.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 Message_VideoMessage::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:proto.Message.VideoMessage.url)
}

// optional string mimetype = 2;
inline bool Message_VideoMessage::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void Message_VideoMessage::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message_VideoMessage::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mimetype)
}
inline std::string* Message_VideoMessage::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mimetype)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void Message_VideoMessage::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mimetype)
}

// optional bytes fileSha256 = 3;
inline bool Message_VideoMessage::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void Message_VideoMessage::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message_VideoMessage::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileSha256)
}
inline std::string* Message_VideoMessage::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileSha256)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void Message_VideoMessage::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileSha256)
}

// optional uint64 fileLength = 4;
inline bool Message_VideoMessage::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_filelength() const {
  return _internal_has_filelength();
}
inline void Message_VideoMessage::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t Message_VideoMessage::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t Message_VideoMessage::filelength() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileLength)
  return _internal_filelength();
}
inline void Message_VideoMessage::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.filelength_ = value;
}
inline void Message_VideoMessage::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileLength)
}

// optional uint32 seconds = 5;
inline bool Message_VideoMessage::_internal_has_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_seconds() const {
  return _internal_has_seconds();
}
inline void Message_VideoMessage::clear_seconds() {
  _impl_.seconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t Message_VideoMessage::_internal_seconds() const {
  return _impl_.seconds_;
}
inline uint32_t Message_VideoMessage::seconds() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.seconds)
  return _internal_seconds();
}
inline void Message_VideoMessage::_internal_set_seconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.seconds_ = value;
}
inline void Message_VideoMessage::set_seconds(uint32_t value) {
  _internal_set_seconds(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.seconds)
}

// optional bytes mediaKey = 6;
inline bool Message_VideoMessage::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void Message_VideoMessage::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message_VideoMessage::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKey)
}
inline std::string* Message_VideoMessage::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.mediaKey)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void Message_VideoMessage::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.mediaKey)
}

// optional string caption = 7;
inline bool Message_VideoMessage::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_caption() const {
  return _internal_has_caption();
}
inline void Message_VideoMessage::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message_VideoMessage::caption() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.caption)
}
inline std::string* Message_VideoMessage::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.caption)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void Message_VideoMessage::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_caption() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  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 Message_VideoMessage::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _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:proto.Message.VideoMessage.caption)
}

// optional bool gifPlayback = 8;
inline bool Message_VideoMessage::_internal_has_gifplayback() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_gifplayback() const {
  return _internal_has_gifplayback();
}
inline void Message_VideoMessage::clear_gifplayback() {
  _impl_.gifplayback_ = false;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline bool Message_VideoMessage::_internal_gifplayback() const {
  return _impl_.gifplayback_;
}
inline bool Message_VideoMessage::gifplayback() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifPlayback)
  return _internal_gifplayback();
}
inline void Message_VideoMessage::_internal_set_gifplayback(bool value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.gifplayback_ = value;
}
inline void Message_VideoMessage::set_gifplayback(bool value) {
  _internal_set_gifplayback(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifPlayback)
}

// optional uint32 height = 9;
inline bool Message_VideoMessage::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_height() const {
  return _internal_has_height();
}
inline void Message_VideoMessage::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t Message_VideoMessage::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t Message_VideoMessage::height() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.height)
  return _internal_height();
}
inline void Message_VideoMessage::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.height_ = value;
}
inline void Message_VideoMessage::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.height)
}

// optional uint32 width = 10;
inline bool Message_VideoMessage::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_width() const {
  return _internal_has_width();
}
inline void Message_VideoMessage::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t Message_VideoMessage::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t Message_VideoMessage::width() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.width)
  return _internal_width();
}
inline void Message_VideoMessage::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.width_ = value;
}
inline void Message_VideoMessage::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.width)
}

// optional bytes fileEncSha256 = 11;
inline bool Message_VideoMessage::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void Message_VideoMessage::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Message_VideoMessage::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.fileEncSha256)
}
inline std::string* Message_VideoMessage::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.fileEncSha256)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void Message_VideoMessage::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.fileEncSha256)
}

// repeated .proto.InteractiveAnnotation interactiveAnnotations = 12;
inline int Message_VideoMessage::_internal_interactiveannotations_size() const {
  return _impl_.interactiveannotations_.size();
}
inline int Message_VideoMessage::interactiveannotations_size() const {
  return _internal_interactiveannotations_size();
}
inline void Message_VideoMessage::clear_interactiveannotations() {
  _impl_.interactiveannotations_.Clear();
}
inline ::proto::InteractiveAnnotation* Message_VideoMessage::mutable_interactiveannotations(int index) {
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.interactiveAnnotations)
  return _impl_.interactiveannotations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >*
Message_VideoMessage::mutable_interactiveannotations() {
  // @@protoc_insertion_point(field_mutable_list:proto.Message.VideoMessage.interactiveAnnotations)
  return &_impl_.interactiveannotations_;
}
inline const ::proto::InteractiveAnnotation& Message_VideoMessage::_internal_interactiveannotations(int index) const {
  return _impl_.interactiveannotations_.Get(index);
}
inline const ::proto::InteractiveAnnotation& Message_VideoMessage::interactiveannotations(int index) const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.interactiveAnnotations)
  return _internal_interactiveannotations(index);
}
inline ::proto::InteractiveAnnotation* Message_VideoMessage::_internal_add_interactiveannotations() {
  return _impl_.interactiveannotations_.Add();
}
inline ::proto::InteractiveAnnotation* Message_VideoMessage::add_interactiveannotations() {
  ::proto::InteractiveAnnotation* _add = _internal_add_interactiveannotations();
  // @@protoc_insertion_point(field_add:proto.Message.VideoMessage.interactiveAnnotations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::InteractiveAnnotation >&
Message_VideoMessage::interactiveannotations() const {
  // @@protoc_insertion_point(field_list:proto.Message.VideoMessage.interactiveAnnotations)
  return _impl_.interactiveannotations_;
}

// optional string directPath = 13;
inline bool Message_VideoMessage::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_directpath() const {
  return _internal_has_directpath();
}
inline void Message_VideoMessage::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Message_VideoMessage::directpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.directPath)
}
inline std::string* Message_VideoMessage::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.directPath)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void Message_VideoMessage::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.directPath)
}

// optional int64 mediaKeyTimestamp = 14;
inline bool Message_VideoMessage::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void Message_VideoMessage::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline int64_t Message_VideoMessage::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t Message_VideoMessage::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void Message_VideoMessage::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.mediakeytimestamp_ = value;
}
inline void Message_VideoMessage::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.mediaKeyTimestamp)
}

// optional bytes jpegThumbnail = 16;
inline bool Message_VideoMessage::_internal_has_jpegthumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_jpegthumbnail() const {
  return _internal_has_jpegthumbnail();
}
inline void Message_VideoMessage::clear_jpegthumbnail() {
  _impl_.jpegthumbnail_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Message_VideoMessage::jpegthumbnail() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.jpegThumbnail)
  return _internal_jpegthumbnail();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_jpegthumbnail(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.jpegthumbnail_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.jpegThumbnail)
}
inline std::string* Message_VideoMessage::mutable_jpegthumbnail() {
  std::string* _s = _internal_mutable_jpegthumbnail();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.jpegThumbnail)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_jpegthumbnail() const {
  return _impl_.jpegthumbnail_.Get();
}
inline void Message_VideoMessage::_internal_set_jpegthumbnail(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.jpegthumbnail_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_jpegthumbnail() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.jpegthumbnail_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_jpegthumbnail() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.jpegThumbnail)
  if (!_internal_has_jpegthumbnail()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.jpegthumbnail_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_jpegthumbnail(std::string* jpegthumbnail) {
  if (jpegthumbnail != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.jpegthumbnail_.SetAllocated(jpegthumbnail, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.jpegthumbnail_.IsDefault()) {
    _impl_.jpegthumbnail_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.jpegThumbnail)
}

// optional .proto.ContextInfo contextInfo = 17;
inline bool Message_VideoMessage::_internal_has_contextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contextinfo_ != nullptr);
  return value;
}
inline bool Message_VideoMessage::has_contextinfo() const {
  return _internal_has_contextinfo();
}
inline void Message_VideoMessage::clear_contextinfo() {
  if (_impl_.contextinfo_ != nullptr) _impl_.contextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::ContextInfo& Message_VideoMessage::_internal_contextinfo() const {
  const ::proto::ContextInfo* p = _impl_.contextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ContextInfo&>(
      ::proto::_ContextInfo_default_instance_);
}
inline const ::proto::ContextInfo& Message_VideoMessage::contextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.contextInfo)
  return _internal_contextinfo();
}
inline void Message_VideoMessage::unsafe_arena_set_allocated_contextinfo(
    ::proto::ContextInfo* contextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contextinfo_);
  }
  _impl_.contextinfo_ = contextinfo;
  if (contextinfo) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.VideoMessage.contextInfo)
}
inline ::proto::ContextInfo* Message_VideoMessage::release_contextinfo() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = 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 ::proto::ContextInfo* Message_VideoMessage::unsafe_arena_release_contextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.contextInfo)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::ContextInfo* temp = _impl_.contextinfo_;
  _impl_.contextinfo_ = nullptr;
  return temp;
}
inline ::proto::ContextInfo* Message_VideoMessage::_internal_mutable_contextinfo() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.contextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ContextInfo>(GetArenaForAllocation());
    _impl_.contextinfo_ = p;
  }
  return _impl_.contextinfo_;
}
inline ::proto::ContextInfo* Message_VideoMessage::mutable_contextinfo() {
  ::proto::ContextInfo* _msg = _internal_mutable_contextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.contextInfo)
  return _msg;
}
inline void Message_VideoMessage::set_allocated_contextinfo(::proto::ContextInfo* contextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contextinfo_;
  }
  if (contextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contextinfo);
    if (message_arena != submessage_arena) {
      contextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.contextinfo_ = contextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.contextInfo)
}

// optional bytes streamingSidecar = 18;
inline bool Message_VideoMessage::_internal_has_streamingsidecar() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_streamingsidecar() const {
  return _internal_has_streamingsidecar();
}
inline void Message_VideoMessage::clear_streamingsidecar() {
  _impl_.streamingsidecar_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Message_VideoMessage::streamingsidecar() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.streamingSidecar)
  return _internal_streamingsidecar();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_streamingsidecar(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.streamingsidecar_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.streamingSidecar)
}
inline std::string* Message_VideoMessage::mutable_streamingsidecar() {
  std::string* _s = _internal_mutable_streamingsidecar();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.streamingSidecar)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_streamingsidecar() const {
  return _impl_.streamingsidecar_.Get();
}
inline void Message_VideoMessage::_internal_set_streamingsidecar(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.streamingsidecar_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_streamingsidecar() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.streamingsidecar_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_streamingsidecar() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.streamingSidecar)
  if (!_internal_has_streamingsidecar()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.streamingsidecar_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.streamingsidecar_.IsDefault()) {
    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_streamingsidecar(std::string* streamingsidecar) {
  if (streamingsidecar != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.streamingsidecar_.SetAllocated(streamingsidecar, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.streamingsidecar_.IsDefault()) {
    _impl_.streamingsidecar_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.streamingSidecar)
}

// optional .proto.Message.VideoMessage.Attribution gifAttribution = 19;
inline bool Message_VideoMessage::_internal_has_gifattribution() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_gifattribution() const {
  return _internal_has_gifattribution();
}
inline void Message_VideoMessage::clear_gifattribution() {
  _impl_.gifattribution_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::_internal_gifattribution() const {
  return static_cast< ::proto::Message_VideoMessage_Attribution >(_impl_.gifattribution_);
}
inline ::proto::Message_VideoMessage_Attribution Message_VideoMessage::gifattribution() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.gifAttribution)
  return _internal_gifattribution();
}
inline void Message_VideoMessage::_internal_set_gifattribution(::proto::Message_VideoMessage_Attribution value) {
  assert(::proto::Message_VideoMessage_Attribution_IsValid(value));
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.gifattribution_ = value;
}
inline void Message_VideoMessage::set_gifattribution(::proto::Message_VideoMessage_Attribution value) {
  _internal_set_gifattribution(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.gifAttribution)
}

// optional bool viewOnce = 20;
inline bool Message_VideoMessage::_internal_has_viewonce() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_viewonce() const {
  return _internal_has_viewonce();
}
inline void Message_VideoMessage::clear_viewonce() {
  _impl_.viewonce_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool Message_VideoMessage::_internal_viewonce() const {
  return _impl_.viewonce_;
}
inline bool Message_VideoMessage::viewonce() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.viewOnce)
  return _internal_viewonce();
}
inline void Message_VideoMessage::_internal_set_viewonce(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.viewonce_ = value;
}
inline void Message_VideoMessage::set_viewonce(bool value) {
  _internal_set_viewonce(value);
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.viewOnce)
}

// optional string thumbnailDirectPath = 21;
inline bool Message_VideoMessage::_internal_has_thumbnaildirectpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_thumbnaildirectpath() const {
  return _internal_has_thumbnaildirectpath();
}
inline void Message_VideoMessage::clear_thumbnaildirectpath() {
  _impl_.thumbnaildirectpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Message_VideoMessage::thumbnaildirectpath() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailDirectPath)
  return _internal_thumbnaildirectpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_thumbnaildirectpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.thumbnaildirectpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailDirectPath)
}
inline std::string* Message_VideoMessage::mutable_thumbnaildirectpath() {
  std::string* _s = _internal_mutable_thumbnaildirectpath();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailDirectPath)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_thumbnaildirectpath() const {
  return _impl_.thumbnaildirectpath_.Get();
}
inline void Message_VideoMessage::_internal_set_thumbnaildirectpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.thumbnaildirectpath_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_thumbnaildirectpath() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.thumbnaildirectpath_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_thumbnaildirectpath() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailDirectPath)
  if (!_internal_has_thumbnaildirectpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.thumbnaildirectpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_thumbnaildirectpath(std::string* thumbnaildirectpath) {
  if (thumbnaildirectpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.thumbnaildirectpath_.SetAllocated(thumbnaildirectpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnaildirectpath_.IsDefault()) {
    _impl_.thumbnaildirectpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailDirectPath)
}

// optional bytes thumbnailSha256 = 22;
inline bool Message_VideoMessage::_internal_has_thumbnailsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_thumbnailsha256() const {
  return _internal_has_thumbnailsha256();
}
inline void Message_VideoMessage::clear_thumbnailsha256() {
  _impl_.thumbnailsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Message_VideoMessage::thumbnailsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailSha256)
  return _internal_thumbnailsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_thumbnailsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.thumbnailsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailSha256)
}
inline std::string* Message_VideoMessage::mutable_thumbnailsha256() {
  std::string* _s = _internal_mutable_thumbnailsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailSha256)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_thumbnailsha256() const {
  return _impl_.thumbnailsha256_.Get();
}
inline void Message_VideoMessage::_internal_set_thumbnailsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.thumbnailsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_thumbnailsha256() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.thumbnailsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_thumbnailsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailSha256)
  if (!_internal_has_thumbnailsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.thumbnailsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_thumbnailsha256(std::string* thumbnailsha256) {
  if (thumbnailsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.thumbnailsha256_.SetAllocated(thumbnailsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailsha256_.IsDefault()) {
    _impl_.thumbnailsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailSha256)
}

// optional bytes thumbnailEncSha256 = 23;
inline bool Message_VideoMessage::_internal_has_thumbnailencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_thumbnailencsha256() const {
  return _internal_has_thumbnailencsha256();
}
inline void Message_VideoMessage::clear_thumbnailencsha256() {
  _impl_.thumbnailencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Message_VideoMessage::thumbnailencsha256() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.thumbnailEncSha256)
  return _internal_thumbnailencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_thumbnailencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.thumbnailencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.thumbnailEncSha256)
}
inline std::string* Message_VideoMessage::mutable_thumbnailencsha256() {
  std::string* _s = _internal_mutable_thumbnailencsha256();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.thumbnailEncSha256)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_thumbnailencsha256() const {
  return _impl_.thumbnailencsha256_.Get();
}
inline void Message_VideoMessage::_internal_set_thumbnailencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.thumbnailencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_thumbnailencsha256() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.thumbnailencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_thumbnailencsha256() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.thumbnailEncSha256)
  if (!_internal_has_thumbnailencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.thumbnailencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_thumbnailencsha256(std::string* thumbnailencsha256) {
  if (thumbnailencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.thumbnailencsha256_.SetAllocated(thumbnailencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.thumbnailencsha256_.IsDefault()) {
    _impl_.thumbnailencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.thumbnailEncSha256)
}

// optional string staticUrl = 24;
inline bool Message_VideoMessage::_internal_has_staticurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Message_VideoMessage::has_staticurl() const {
  return _internal_has_staticurl();
}
inline void Message_VideoMessage::clear_staticurl() {
  _impl_.staticurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& Message_VideoMessage::staticurl() const {
  // @@protoc_insertion_point(field_get:proto.Message.VideoMessage.staticUrl)
  return _internal_staticurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message_VideoMessage::set_staticurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00001000u;
 _impl_.staticurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.VideoMessage.staticUrl)
}
inline std::string* Message_VideoMessage::mutable_staticurl() {
  std::string* _s = _internal_mutable_staticurl();
  // @@protoc_insertion_point(field_mutable:proto.Message.VideoMessage.staticUrl)
  return _s;
}
inline const std::string& Message_VideoMessage::_internal_staticurl() const {
  return _impl_.staticurl_.Get();
}
inline void Message_VideoMessage::_internal_set_staticurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.staticurl_.Set(value, GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::_internal_mutable_staticurl() {
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.staticurl_.Mutable(GetArenaForAllocation());
}
inline std::string* Message_VideoMessage::release_staticurl() {
  // @@protoc_insertion_point(field_release:proto.Message.VideoMessage.staticUrl)
  if (!_internal_has_staticurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  auto* p = _impl_.staticurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.staticurl_.IsDefault()) {
    _impl_.staticurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message_VideoMessage::set_allocated_staticurl(std::string* staticurl) {
  if (staticurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.staticurl_.SetAllocated(staticurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.staticurl_.IsDefault()) {
    _impl_.staticurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.VideoMessage.staticUrl)
}

// -------------------------------------------------------------------

// Message

// optional string conversation = 1;
inline bool Message::_internal_has_conversation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Message::has_conversation() const {
  return _internal_has_conversation();
}
inline void Message::clear_conversation() {
  _impl_.conversation_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message::conversation() const {
  // @@protoc_insertion_point(field_get:proto.Message.conversation)
  return _internal_conversation();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Message::set_conversation(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.conversation_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Message.conversation)
}
inline std::string* Message::mutable_conversation() {
  std::string* _s = _internal_mutable_conversation();
  // @@protoc_insertion_point(field_mutable:proto.Message.conversation)
  return _s;
}
inline const std::string& Message::_internal_conversation() const {
  return _impl_.conversation_.Get();
}
inline void Message::_internal_set_conversation(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.conversation_.Set(value, GetArenaForAllocation());
}
inline std::string* Message::_internal_mutable_conversation() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.conversation_.Mutable(GetArenaForAllocation());
}
inline std::string* Message::release_conversation() {
  // @@protoc_insertion_point(field_release:proto.Message.conversation)
  if (!_internal_has_conversation()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.conversation_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversation_.IsDefault()) {
    _impl_.conversation_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Message::set_allocated_conversation(std::string* conversation) {
  if (conversation != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.conversation_.SetAllocated(conversation, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.conversation_.IsDefault()) {
    _impl_.conversation_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Message.conversation)
}

// optional .proto.Message.SenderKeyDistributionMessage senderKeyDistributionMessage = 2;
inline bool Message::_internal_has_senderkeydistributionmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.senderkeydistributionmessage_ != nullptr);
  return value;
}
inline bool Message::has_senderkeydistributionmessage() const {
  return _internal_has_senderkeydistributionmessage();
}
inline void Message::clear_senderkeydistributionmessage() {
  if (_impl_.senderkeydistributionmessage_ != nullptr) _impl_.senderkeydistributionmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_senderkeydistributionmessage() const {
  const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.senderkeydistributionmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SenderKeyDistributionMessage&>(
      ::proto::_Message_SenderKeyDistributionMessage_default_instance_);
}
inline const ::proto::Message_SenderKeyDistributionMessage& Message::senderkeydistributionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.senderKeyDistributionMessage)
  return _internal_senderkeydistributionmessage();
}
inline void Message::unsafe_arena_set_allocated_senderkeydistributionmessage(
    ::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderkeydistributionmessage_);
  }
  _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage;
  if (senderkeydistributionmessage) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.senderKeyDistributionMessage)
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::release_senderkeydistributionmessage() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_;
  _impl_.senderkeydistributionmessage_ = 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 ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_senderkeydistributionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.senderKeyDistributionMessage)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.senderkeydistributionmessage_;
  _impl_.senderkeydistributionmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_senderkeydistributionmessage() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.senderkeydistributionmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation());
    _impl_.senderkeydistributionmessage_ = p;
  }
  return _impl_.senderkeydistributionmessage_;
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_senderkeydistributionmessage() {
  ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_senderkeydistributionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.senderKeyDistributionMessage)
  return _msg;
}
inline void Message::set_allocated_senderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* senderkeydistributionmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.senderkeydistributionmessage_;
  }
  if (senderkeydistributionmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderkeydistributionmessage);
    if (message_arena != submessage_arena) {
      senderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, senderkeydistributionmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.senderkeydistributionmessage_ = senderkeydistributionmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.senderKeyDistributionMessage)
}

// optional .proto.Message.ImageMessage imageMessage = 3;
inline bool Message::_internal_has_imagemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.imagemessage_ != nullptr);
  return value;
}
inline bool Message::has_imagemessage() const {
  return _internal_has_imagemessage();
}
inline void Message::clear_imagemessage() {
  if (_impl_.imagemessage_ != nullptr) _impl_.imagemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message_ImageMessage& Message::_internal_imagemessage() const {
  const ::proto::Message_ImageMessage* p = _impl_.imagemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ImageMessage&>(
      ::proto::_Message_ImageMessage_default_instance_);
}
inline const ::proto::Message_ImageMessage& Message::imagemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.imageMessage)
  return _internal_imagemessage();
}
inline void Message::unsafe_arena_set_allocated_imagemessage(
    ::proto::Message_ImageMessage* imagemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.imagemessage_);
  }
  _impl_.imagemessage_ = imagemessage;
  if (imagemessage) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.imageMessage)
}
inline ::proto::Message_ImageMessage* Message::release_imagemessage() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ImageMessage* temp = _impl_.imagemessage_;
  _impl_.imagemessage_ = 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 ::proto::Message_ImageMessage* Message::unsafe_arena_release_imagemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.imageMessage)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message_ImageMessage* temp = _impl_.imagemessage_;
  _impl_.imagemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ImageMessage* Message::_internal_mutable_imagemessage() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.imagemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ImageMessage>(GetArenaForAllocation());
    _impl_.imagemessage_ = p;
  }
  return _impl_.imagemessage_;
}
inline ::proto::Message_ImageMessage* Message::mutable_imagemessage() {
  ::proto::Message_ImageMessage* _msg = _internal_mutable_imagemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.imageMessage)
  return _msg;
}
inline void Message::set_allocated_imagemessage(::proto::Message_ImageMessage* imagemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.imagemessage_;
  }
  if (imagemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(imagemessage);
    if (message_arena != submessage_arena) {
      imagemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, imagemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.imagemessage_ = imagemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.imageMessage)
}

// optional .proto.Message.ContactMessage contactMessage = 4;
inline bool Message::_internal_has_contactmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contactmessage_ != nullptr);
  return value;
}
inline bool Message::has_contactmessage() const {
  return _internal_has_contactmessage();
}
inline void Message::clear_contactmessage() {
  if (_impl_.contactmessage_ != nullptr) _impl_.contactmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::Message_ContactMessage& Message::_internal_contactmessage() const {
  const ::proto::Message_ContactMessage* p = _impl_.contactmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ContactMessage&>(
      ::proto::_Message_ContactMessage_default_instance_);
}
inline const ::proto::Message_ContactMessage& Message::contactmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.contactMessage)
  return _internal_contactmessage();
}
inline void Message::unsafe_arena_set_allocated_contactmessage(
    ::proto::Message_ContactMessage* contactmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactmessage_);
  }
  _impl_.contactmessage_ = contactmessage;
  if (contactmessage) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactMessage)
}
inline ::proto::Message_ContactMessage* Message::release_contactmessage() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_ContactMessage* temp = _impl_.contactmessage_;
  _impl_.contactmessage_ = 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 ::proto::Message_ContactMessage* Message::unsafe_arena_release_contactmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.contactMessage)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Message_ContactMessage* temp = _impl_.contactmessage_;
  _impl_.contactmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ContactMessage* Message::_internal_mutable_contactmessage() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.contactmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ContactMessage>(GetArenaForAllocation());
    _impl_.contactmessage_ = p;
  }
  return _impl_.contactmessage_;
}
inline ::proto::Message_ContactMessage* Message::mutable_contactmessage() {
  ::proto::Message_ContactMessage* _msg = _internal_mutable_contactmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.contactMessage)
  return _msg;
}
inline void Message::set_allocated_contactmessage(::proto::Message_ContactMessage* contactmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contactmessage_;
  }
  if (contactmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactmessage);
    if (message_arena != submessage_arena) {
      contactmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contactmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.contactmessage_ = contactmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.contactMessage)
}

// optional .proto.Message.LocationMessage locationMessage = 5;
inline bool Message::_internal_has_locationmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.locationmessage_ != nullptr);
  return value;
}
inline bool Message::has_locationmessage() const {
  return _internal_has_locationmessage();
}
inline void Message::clear_locationmessage() {
  if (_impl_.locationmessage_ != nullptr) _impl_.locationmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Message_LocationMessage& Message::_internal_locationmessage() const {
  const ::proto::Message_LocationMessage* p = _impl_.locationmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LocationMessage&>(
      ::proto::_Message_LocationMessage_default_instance_);
}
inline const ::proto::Message_LocationMessage& Message::locationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.locationMessage)
  return _internal_locationmessage();
}
inline void Message::unsafe_arena_set_allocated_locationmessage(
    ::proto::Message_LocationMessage* locationmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.locationmessage_);
  }
  _impl_.locationmessage_ = locationmessage;
  if (locationmessage) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.locationMessage)
}
inline ::proto::Message_LocationMessage* Message::release_locationmessage() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_LocationMessage* temp = _impl_.locationmessage_;
  _impl_.locationmessage_ = 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 ::proto::Message_LocationMessage* Message::unsafe_arena_release_locationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.locationMessage)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Message_LocationMessage* temp = _impl_.locationmessage_;
  _impl_.locationmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_LocationMessage* Message::_internal_mutable_locationmessage() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.locationmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_LocationMessage>(GetArenaForAllocation());
    _impl_.locationmessage_ = p;
  }
  return _impl_.locationmessage_;
}
inline ::proto::Message_LocationMessage* Message::mutable_locationmessage() {
  ::proto::Message_LocationMessage* _msg = _internal_mutable_locationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.locationMessage)
  return _msg;
}
inline void Message::set_allocated_locationmessage(::proto::Message_LocationMessage* locationmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.locationmessage_;
  }
  if (locationmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(locationmessage);
    if (message_arena != submessage_arena) {
      locationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, locationmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.locationmessage_ = locationmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.locationMessage)
}

// optional .proto.Message.ExtendedTextMessage extendedTextMessage = 6;
inline bool Message::_internal_has_extendedtextmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.extendedtextmessage_ != nullptr);
  return value;
}
inline bool Message::has_extendedtextmessage() const {
  return _internal_has_extendedtextmessage();
}
inline void Message::clear_extendedtextmessage() {
  if (_impl_.extendedtextmessage_ != nullptr) _impl_.extendedtextmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::Message_ExtendedTextMessage& Message::_internal_extendedtextmessage() const {
  const ::proto::Message_ExtendedTextMessage* p = _impl_.extendedtextmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ExtendedTextMessage&>(
      ::proto::_Message_ExtendedTextMessage_default_instance_);
}
inline const ::proto::Message_ExtendedTextMessage& Message::extendedtextmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.extendedTextMessage)
  return _internal_extendedtextmessage();
}
inline void Message::unsafe_arena_set_allocated_extendedtextmessage(
    ::proto::Message_ExtendedTextMessage* extendedtextmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.extendedtextmessage_);
  }
  _impl_.extendedtextmessage_ = extendedtextmessage;
  if (extendedtextmessage) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.extendedTextMessage)
}
inline ::proto::Message_ExtendedTextMessage* Message::release_extendedtextmessage() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_;
  _impl_.extendedtextmessage_ = 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 ::proto::Message_ExtendedTextMessage* Message::unsafe_arena_release_extendedtextmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.extendedTextMessage)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::Message_ExtendedTextMessage* temp = _impl_.extendedtextmessage_;
  _impl_.extendedtextmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ExtendedTextMessage* Message::_internal_mutable_extendedtextmessage() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.extendedtextmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ExtendedTextMessage>(GetArenaForAllocation());
    _impl_.extendedtextmessage_ = p;
  }
  return _impl_.extendedtextmessage_;
}
inline ::proto::Message_ExtendedTextMessage* Message::mutable_extendedtextmessage() {
  ::proto::Message_ExtendedTextMessage* _msg = _internal_mutable_extendedtextmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.extendedTextMessage)
  return _msg;
}
inline void Message::set_allocated_extendedtextmessage(::proto::Message_ExtendedTextMessage* extendedtextmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.extendedtextmessage_;
  }
  if (extendedtextmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(extendedtextmessage);
    if (message_arena != submessage_arena) {
      extendedtextmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, extendedtextmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.extendedtextmessage_ = extendedtextmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.extendedTextMessage)
}

// optional .proto.Message.DocumentMessage documentMessage = 7;
inline bool Message::_internal_has_documentmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.documentmessage_ != nullptr);
  return value;
}
inline bool Message::has_documentmessage() const {
  return _internal_has_documentmessage();
}
inline void Message::clear_documentmessage() {
  if (_impl_.documentmessage_ != nullptr) _impl_.documentmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::Message_DocumentMessage& Message::_internal_documentmessage() const {
  const ::proto::Message_DocumentMessage* p = _impl_.documentmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DocumentMessage&>(
      ::proto::_Message_DocumentMessage_default_instance_);
}
inline const ::proto::Message_DocumentMessage& Message::documentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.documentMessage)
  return _internal_documentmessage();
}
inline void Message::unsafe_arena_set_allocated_documentmessage(
    ::proto::Message_DocumentMessage* documentmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentmessage_);
  }
  _impl_.documentmessage_ = documentmessage;
  if (documentmessage) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentMessage)
}
inline ::proto::Message_DocumentMessage* Message::release_documentmessage() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_;
  _impl_.documentmessage_ = 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 ::proto::Message_DocumentMessage* Message::unsafe_arena_release_documentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.documentMessage)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::Message_DocumentMessage* temp = _impl_.documentmessage_;
  _impl_.documentmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_DocumentMessage* Message::_internal_mutable_documentmessage() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.documentmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_DocumentMessage>(GetArenaForAllocation());
    _impl_.documentmessage_ = p;
  }
  return _impl_.documentmessage_;
}
inline ::proto::Message_DocumentMessage* Message::mutable_documentmessage() {
  ::proto::Message_DocumentMessage* _msg = _internal_mutable_documentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.documentMessage)
  return _msg;
}
inline void Message::set_allocated_documentmessage(::proto::Message_DocumentMessage* documentmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.documentmessage_;
  }
  if (documentmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentmessage);
    if (message_arena != submessage_arena) {
      documentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, documentmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.documentmessage_ = documentmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.documentMessage)
}

// optional .proto.Message.AudioMessage audioMessage = 8;
inline bool Message::_internal_has_audiomessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.audiomessage_ != nullptr);
  return value;
}
inline bool Message::has_audiomessage() const {
  return _internal_has_audiomessage();
}
inline void Message::clear_audiomessage() {
  if (_impl_.audiomessage_ != nullptr) _impl_.audiomessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::Message_AudioMessage& Message::_internal_audiomessage() const {
  const ::proto::Message_AudioMessage* p = _impl_.audiomessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_AudioMessage&>(
      ::proto::_Message_AudioMessage_default_instance_);
}
inline const ::proto::Message_AudioMessage& Message::audiomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.audioMessage)
  return _internal_audiomessage();
}
inline void Message::unsafe_arena_set_allocated_audiomessage(
    ::proto::Message_AudioMessage* audiomessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.audiomessage_);
  }
  _impl_.audiomessage_ = audiomessage;
  if (audiomessage) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.audioMessage)
}
inline ::proto::Message_AudioMessage* Message::release_audiomessage() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_AudioMessage* temp = _impl_.audiomessage_;
  _impl_.audiomessage_ = 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 ::proto::Message_AudioMessage* Message::unsafe_arena_release_audiomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.audioMessage)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::Message_AudioMessage* temp = _impl_.audiomessage_;
  _impl_.audiomessage_ = nullptr;
  return temp;
}
inline ::proto::Message_AudioMessage* Message::_internal_mutable_audiomessage() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.audiomessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_AudioMessage>(GetArenaForAllocation());
    _impl_.audiomessage_ = p;
  }
  return _impl_.audiomessage_;
}
inline ::proto::Message_AudioMessage* Message::mutable_audiomessage() {
  ::proto::Message_AudioMessage* _msg = _internal_mutable_audiomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.audioMessage)
  return _msg;
}
inline void Message::set_allocated_audiomessage(::proto::Message_AudioMessage* audiomessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.audiomessage_;
  }
  if (audiomessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(audiomessage);
    if (message_arena != submessage_arena) {
      audiomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, audiomessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.audiomessage_ = audiomessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.audioMessage)
}

// optional .proto.Message.VideoMessage videoMessage = 9;
inline bool Message::_internal_has_videomessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.videomessage_ != nullptr);
  return value;
}
inline bool Message::has_videomessage() const {
  return _internal_has_videomessage();
}
inline void Message::clear_videomessage() {
  if (_impl_.videomessage_ != nullptr) _impl_.videomessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::Message_VideoMessage& Message::_internal_videomessage() const {
  const ::proto::Message_VideoMessage* p = _impl_.videomessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_VideoMessage&>(
      ::proto::_Message_VideoMessage_default_instance_);
}
inline const ::proto::Message_VideoMessage& Message::videomessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.videoMessage)
  return _internal_videomessage();
}
inline void Message::unsafe_arena_set_allocated_videomessage(
    ::proto::Message_VideoMessage* videomessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.videomessage_);
  }
  _impl_.videomessage_ = videomessage;
  if (videomessage) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.videoMessage)
}
inline ::proto::Message_VideoMessage* Message::release_videomessage() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::Message_VideoMessage* temp = _impl_.videomessage_;
  _impl_.videomessage_ = 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 ::proto::Message_VideoMessage* Message::unsafe_arena_release_videomessage() {
  // @@protoc_insertion_point(field_release:proto.Message.videoMessage)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::Message_VideoMessage* temp = _impl_.videomessage_;
  _impl_.videomessage_ = nullptr;
  return temp;
}
inline ::proto::Message_VideoMessage* Message::_internal_mutable_videomessage() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.videomessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_VideoMessage>(GetArenaForAllocation());
    _impl_.videomessage_ = p;
  }
  return _impl_.videomessage_;
}
inline ::proto::Message_VideoMessage* Message::mutable_videomessage() {
  ::proto::Message_VideoMessage* _msg = _internal_mutable_videomessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.videoMessage)
  return _msg;
}
inline void Message::set_allocated_videomessage(::proto::Message_VideoMessage* videomessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.videomessage_;
  }
  if (videomessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(videomessage);
    if (message_arena != submessage_arena) {
      videomessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, videomessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.videomessage_ = videomessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.videoMessage)
}

// optional .proto.Message.Call call = 10;
inline bool Message::_internal_has_call() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.call_ != nullptr);
  return value;
}
inline bool Message::has_call() const {
  return _internal_has_call();
}
inline void Message::clear_call() {
  if (_impl_.call_ != nullptr) _impl_.call_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::proto::Message_Call& Message::_internal_call() const {
  const ::proto::Message_Call* p = _impl_.call_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_Call&>(
      ::proto::_Message_Call_default_instance_);
}
inline const ::proto::Message_Call& Message::call() const {
  // @@protoc_insertion_point(field_get:proto.Message.call)
  return _internal_call();
}
inline void Message::unsafe_arena_set_allocated_call(
    ::proto::Message_Call* call) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.call_);
  }
  _impl_.call_ = call;
  if (call) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.call)
}
inline ::proto::Message_Call* Message::release_call() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::Message_Call* temp = _impl_.call_;
  _impl_.call_ = 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 ::proto::Message_Call* Message::unsafe_arena_release_call() {
  // @@protoc_insertion_point(field_release:proto.Message.call)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::Message_Call* temp = _impl_.call_;
  _impl_.call_ = nullptr;
  return temp;
}
inline ::proto::Message_Call* Message::_internal_mutable_call() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.call_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_Call>(GetArenaForAllocation());
    _impl_.call_ = p;
  }
  return _impl_.call_;
}
inline ::proto::Message_Call* Message::mutable_call() {
  ::proto::Message_Call* _msg = _internal_mutable_call();
  // @@protoc_insertion_point(field_mutable:proto.Message.call)
  return _msg;
}
inline void Message::set_allocated_call(::proto::Message_Call* call) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.call_;
  }
  if (call) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(call);
    if (message_arena != submessage_arena) {
      call = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, call, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.call_ = call;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.call)
}

// optional .proto.Message.Chat chat = 11;
inline bool Message::_internal_has_chat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.chat_ != nullptr);
  return value;
}
inline bool Message::has_chat() const {
  return _internal_has_chat();
}
inline void Message::clear_chat() {
  if (_impl_.chat_ != nullptr) _impl_.chat_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::proto::Message_Chat& Message::_internal_chat() const {
  const ::proto::Message_Chat* p = _impl_.chat_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_Chat&>(
      ::proto::_Message_Chat_default_instance_);
}
inline const ::proto::Message_Chat& Message::chat() const {
  // @@protoc_insertion_point(field_get:proto.Message.chat)
  return _internal_chat();
}
inline void Message::unsafe_arena_set_allocated_chat(
    ::proto::Message_Chat* chat) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.chat_);
  }
  _impl_.chat_ = chat;
  if (chat) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.chat)
}
inline ::proto::Message_Chat* Message::release_chat() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::Message_Chat* temp = _impl_.chat_;
  _impl_.chat_ = 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 ::proto::Message_Chat* Message::unsafe_arena_release_chat() {
  // @@protoc_insertion_point(field_release:proto.Message.chat)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::Message_Chat* temp = _impl_.chat_;
  _impl_.chat_ = nullptr;
  return temp;
}
inline ::proto::Message_Chat* Message::_internal_mutable_chat() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.chat_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_Chat>(GetArenaForAllocation());
    _impl_.chat_ = p;
  }
  return _impl_.chat_;
}
inline ::proto::Message_Chat* Message::mutable_chat() {
  ::proto::Message_Chat* _msg = _internal_mutable_chat();
  // @@protoc_insertion_point(field_mutable:proto.Message.chat)
  return _msg;
}
inline void Message::set_allocated_chat(::proto::Message_Chat* chat) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.chat_;
  }
  if (chat) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(chat);
    if (message_arena != submessage_arena) {
      chat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, chat, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.chat_ = chat;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.chat)
}

// optional .proto.Message.ProtocolMessage protocolMessage = 12;
inline bool Message::_internal_has_protocolmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.protocolmessage_ != nullptr);
  return value;
}
inline bool Message::has_protocolmessage() const {
  return _internal_has_protocolmessage();
}
inline void Message::clear_protocolmessage() {
  if (_impl_.protocolmessage_ != nullptr) _impl_.protocolmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::proto::Message_ProtocolMessage& Message::_internal_protocolmessage() const {
  const ::proto::Message_ProtocolMessage* p = _impl_.protocolmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProtocolMessage&>(
      ::proto::_Message_ProtocolMessage_default_instance_);
}
inline const ::proto::Message_ProtocolMessage& Message::protocolmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.protocolMessage)
  return _internal_protocolmessage();
}
inline void Message::unsafe_arena_set_allocated_protocolmessage(
    ::proto::Message_ProtocolMessage* protocolmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.protocolmessage_);
  }
  _impl_.protocolmessage_ = protocolmessage;
  if (protocolmessage) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.protocolMessage)
}
inline ::proto::Message_ProtocolMessage* Message::release_protocolmessage() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_;
  _impl_.protocolmessage_ = 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 ::proto::Message_ProtocolMessage* Message::unsafe_arena_release_protocolmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.protocolMessage)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::Message_ProtocolMessage* temp = _impl_.protocolmessage_;
  _impl_.protocolmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ProtocolMessage* Message::_internal_mutable_protocolmessage() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.protocolmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ProtocolMessage>(GetArenaForAllocation());
    _impl_.protocolmessage_ = p;
  }
  return _impl_.protocolmessage_;
}
inline ::proto::Message_ProtocolMessage* Message::mutable_protocolmessage() {
  ::proto::Message_ProtocolMessage* _msg = _internal_mutable_protocolmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.protocolMessage)
  return _msg;
}
inline void Message::set_allocated_protocolmessage(::proto::Message_ProtocolMessage* protocolmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.protocolmessage_;
  }
  if (protocolmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(protocolmessage);
    if (message_arena != submessage_arena) {
      protocolmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, protocolmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.protocolmessage_ = protocolmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.protocolMessage)
}

// optional .proto.Message.ContactsArrayMessage contactsArrayMessage = 13;
inline bool Message::_internal_has_contactsarraymessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contactsarraymessage_ != nullptr);
  return value;
}
inline bool Message::has_contactsarraymessage() const {
  return _internal_has_contactsarraymessage();
}
inline void Message::clear_contactsarraymessage() {
  if (_impl_.contactsarraymessage_ != nullptr) _impl_.contactsarraymessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::Message_ContactsArrayMessage& Message::_internal_contactsarraymessage() const {
  const ::proto::Message_ContactsArrayMessage* p = _impl_.contactsarraymessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ContactsArrayMessage&>(
      ::proto::_Message_ContactsArrayMessage_default_instance_);
}
inline const ::proto::Message_ContactsArrayMessage& Message::contactsarraymessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.contactsArrayMessage)
  return _internal_contactsarraymessage();
}
inline void Message::unsafe_arena_set_allocated_contactsarraymessage(
    ::proto::Message_ContactsArrayMessage* contactsarraymessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactsarraymessage_);
  }
  _impl_.contactsarraymessage_ = contactsarraymessage;
  if (contactsarraymessage) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.contactsArrayMessage)
}
inline ::proto::Message_ContactsArrayMessage* Message::release_contactsarraymessage() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_;
  _impl_.contactsarraymessage_ = 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 ::proto::Message_ContactsArrayMessage* Message::unsafe_arena_release_contactsarraymessage() {
  // @@protoc_insertion_point(field_release:proto.Message.contactsArrayMessage)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::Message_ContactsArrayMessage* temp = _impl_.contactsarraymessage_;
  _impl_.contactsarraymessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ContactsArrayMessage* Message::_internal_mutable_contactsarraymessage() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.contactsarraymessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ContactsArrayMessage>(GetArenaForAllocation());
    _impl_.contactsarraymessage_ = p;
  }
  return _impl_.contactsarraymessage_;
}
inline ::proto::Message_ContactsArrayMessage* Message::mutable_contactsarraymessage() {
  ::proto::Message_ContactsArrayMessage* _msg = _internal_mutable_contactsarraymessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.contactsArrayMessage)
  return _msg;
}
inline void Message::set_allocated_contactsarraymessage(::proto::Message_ContactsArrayMessage* contactsarraymessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contactsarraymessage_;
  }
  if (contactsarraymessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactsarraymessage);
    if (message_arena != submessage_arena) {
      contactsarraymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contactsarraymessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.contactsarraymessage_ = contactsarraymessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.contactsArrayMessage)
}

// optional .proto.Message.HighlyStructuredMessage highlyStructuredMessage = 14;
inline bool Message::_internal_has_highlystructuredmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.highlystructuredmessage_ != nullptr);
  return value;
}
inline bool Message::has_highlystructuredmessage() const {
  return _internal_has_highlystructuredmessage();
}
inline void Message::clear_highlystructuredmessage() {
  if (_impl_.highlystructuredmessage_ != nullptr) _impl_.highlystructuredmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::Message_HighlyStructuredMessage& Message::_internal_highlystructuredmessage() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.highlystructuredmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& Message::highlystructuredmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.highlyStructuredMessage)
  return _internal_highlystructuredmessage();
}
inline void Message::unsafe_arena_set_allocated_highlystructuredmessage(
    ::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.highlystructuredmessage_);
  }
  _impl_.highlystructuredmessage_ = highlystructuredmessage;
  if (highlystructuredmessage) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.highlyStructuredMessage)
}
inline ::proto::Message_HighlyStructuredMessage* Message::release_highlystructuredmessage() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_;
  _impl_.highlystructuredmessage_ = 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 ::proto::Message_HighlyStructuredMessage* Message::unsafe_arena_release_highlystructuredmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.highlyStructuredMessage)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.highlystructuredmessage_;
  _impl_.highlystructuredmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* Message::_internal_mutable_highlystructuredmessage() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.highlystructuredmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.highlystructuredmessage_ = p;
  }
  return _impl_.highlystructuredmessage_;
}
inline ::proto::Message_HighlyStructuredMessage* Message::mutable_highlystructuredmessage() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_highlystructuredmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.highlyStructuredMessage)
  return _msg;
}
inline void Message::set_allocated_highlystructuredmessage(::proto::Message_HighlyStructuredMessage* highlystructuredmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.highlystructuredmessage_;
  }
  if (highlystructuredmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(highlystructuredmessage);
    if (message_arena != submessage_arena) {
      highlystructuredmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, highlystructuredmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.highlystructuredmessage_ = highlystructuredmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.highlyStructuredMessage)
}

// optional .proto.Message.SenderKeyDistributionMessage fastRatchetKeySenderKeyDistributionMessage = 15;
inline bool Message::_internal_has_fastratchetkeysenderkeydistributionmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr);
  return value;
}
inline bool Message::has_fastratchetkeysenderkeydistributionmessage() const {
  return _internal_has_fastratchetkeysenderkeydistributionmessage();
}
inline void Message::clear_fastratchetkeysenderkeydistributionmessage() {
  if (_impl_.fastratchetkeysenderkeydistributionmessage_ != nullptr) _impl_.fastratchetkeysenderkeydistributionmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::proto::Message_SenderKeyDistributionMessage& Message::_internal_fastratchetkeysenderkeydistributionmessage() const {
  const ::proto::Message_SenderKeyDistributionMessage* p = _impl_.fastratchetkeysenderkeydistributionmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SenderKeyDistributionMessage&>(
      ::proto::_Message_SenderKeyDistributionMessage_default_instance_);
}
inline const ::proto::Message_SenderKeyDistributionMessage& Message::fastratchetkeysenderkeydistributionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
  return _internal_fastratchetkeysenderkeydistributionmessage();
}
inline void Message::unsafe_arena_set_allocated_fastratchetkeysenderkeydistributionmessage(
    ::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.fastratchetkeysenderkeydistributionmessage_);
  }
  _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage;
  if (fastratchetkeysenderkeydistributionmessage) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::release_fastratchetkeysenderkeydistributionmessage() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_;
  _impl_.fastratchetkeysenderkeydistributionmessage_ = 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 ::proto::Message_SenderKeyDistributionMessage* Message::unsafe_arena_release_fastratchetkeysenderkeydistributionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::Message_SenderKeyDistributionMessage* temp = _impl_.fastratchetkeysenderkeydistributionmessage_;
  _impl_.fastratchetkeysenderkeydistributionmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::_internal_mutable_fastratchetkeysenderkeydistributionmessage() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.fastratchetkeysenderkeydistributionmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_SenderKeyDistributionMessage>(GetArenaForAllocation());
    _impl_.fastratchetkeysenderkeydistributionmessage_ = p;
  }
  return _impl_.fastratchetkeysenderkeydistributionmessage_;
}
inline ::proto::Message_SenderKeyDistributionMessage* Message::mutable_fastratchetkeysenderkeydistributionmessage() {
  ::proto::Message_SenderKeyDistributionMessage* _msg = _internal_mutable_fastratchetkeysenderkeydistributionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
  return _msg;
}
inline void Message::set_allocated_fastratchetkeysenderkeydistributionmessage(::proto::Message_SenderKeyDistributionMessage* fastratchetkeysenderkeydistributionmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.fastratchetkeysenderkeydistributionmessage_;
  }
  if (fastratchetkeysenderkeydistributionmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(fastratchetkeysenderkeydistributionmessage);
    if (message_arena != submessage_arena) {
      fastratchetkeysenderkeydistributionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fastratchetkeysenderkeydistributionmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.fastratchetkeysenderkeydistributionmessage_ = fastratchetkeysenderkeydistributionmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.fastRatchetKeySenderKeyDistributionMessage)
}

// optional .proto.Message.SendPaymentMessage sendPaymentMessage = 16;
inline bool Message::_internal_has_sendpaymentmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sendpaymentmessage_ != nullptr);
  return value;
}
inline bool Message::has_sendpaymentmessage() const {
  return _internal_has_sendpaymentmessage();
}
inline void Message::clear_sendpaymentmessage() {
  if (_impl_.sendpaymentmessage_ != nullptr) _impl_.sendpaymentmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::proto::Message_SendPaymentMessage& Message::_internal_sendpaymentmessage() const {
  const ::proto::Message_SendPaymentMessage* p = _impl_.sendpaymentmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_SendPaymentMessage&>(
      ::proto::_Message_SendPaymentMessage_default_instance_);
}
inline const ::proto::Message_SendPaymentMessage& Message::sendpaymentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.sendPaymentMessage)
  return _internal_sendpaymentmessage();
}
inline void Message::unsafe_arena_set_allocated_sendpaymentmessage(
    ::proto::Message_SendPaymentMessage* sendpaymentmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendpaymentmessage_);
  }
  _impl_.sendpaymentmessage_ = sendpaymentmessage;
  if (sendpaymentmessage) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.sendPaymentMessage)
}
inline ::proto::Message_SendPaymentMessage* Message::release_sendpaymentmessage() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_;
  _impl_.sendpaymentmessage_ = 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 ::proto::Message_SendPaymentMessage* Message::unsafe_arena_release_sendpaymentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.sendPaymentMessage)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::Message_SendPaymentMessage* temp = _impl_.sendpaymentmessage_;
  _impl_.sendpaymentmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_SendPaymentMessage* Message::_internal_mutable_sendpaymentmessage() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.sendpaymentmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_SendPaymentMessage>(GetArenaForAllocation());
    _impl_.sendpaymentmessage_ = p;
  }
  return _impl_.sendpaymentmessage_;
}
inline ::proto::Message_SendPaymentMessage* Message::mutable_sendpaymentmessage() {
  ::proto::Message_SendPaymentMessage* _msg = _internal_mutable_sendpaymentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.sendPaymentMessage)
  return _msg;
}
inline void Message::set_allocated_sendpaymentmessage(::proto::Message_SendPaymentMessage* sendpaymentmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sendpaymentmessage_;
  }
  if (sendpaymentmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendpaymentmessage);
    if (message_arena != submessage_arena) {
      sendpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sendpaymentmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.sendpaymentmessage_ = sendpaymentmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.sendPaymentMessage)
}

// optional .proto.Message.LiveLocationMessage liveLocationMessage = 18;
inline bool Message::_internal_has_livelocationmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.livelocationmessage_ != nullptr);
  return value;
}
inline bool Message::has_livelocationmessage() const {
  return _internal_has_livelocationmessage();
}
inline void Message::clear_livelocationmessage() {
  if (_impl_.livelocationmessage_ != nullptr) _impl_.livelocationmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::proto::Message_LiveLocationMessage& Message::_internal_livelocationmessage() const {
  const ::proto::Message_LiveLocationMessage* p = _impl_.livelocationmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LiveLocationMessage&>(
      ::proto::_Message_LiveLocationMessage_default_instance_);
}
inline const ::proto::Message_LiveLocationMessage& Message::livelocationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.liveLocationMessage)
  return _internal_livelocationmessage();
}
inline void Message::unsafe_arena_set_allocated_livelocationmessage(
    ::proto::Message_LiveLocationMessage* livelocationmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.livelocationmessage_);
  }
  _impl_.livelocationmessage_ = livelocationmessage;
  if (livelocationmessage) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.liveLocationMessage)
}
inline ::proto::Message_LiveLocationMessage* Message::release_livelocationmessage() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_;
  _impl_.livelocationmessage_ = 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 ::proto::Message_LiveLocationMessage* Message::unsafe_arena_release_livelocationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.liveLocationMessage)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::Message_LiveLocationMessage* temp = _impl_.livelocationmessage_;
  _impl_.livelocationmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_LiveLocationMessage* Message::_internal_mutable_livelocationmessage() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.livelocationmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation());
    _impl_.livelocationmessage_ = p;
  }
  return _impl_.livelocationmessage_;
}
inline ::proto::Message_LiveLocationMessage* Message::mutable_livelocationmessage() {
  ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_livelocationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.liveLocationMessage)
  return _msg;
}
inline void Message::set_allocated_livelocationmessage(::proto::Message_LiveLocationMessage* livelocationmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.livelocationmessage_;
  }
  if (livelocationmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(livelocationmessage);
    if (message_arena != submessage_arena) {
      livelocationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, livelocationmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.livelocationmessage_ = livelocationmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.liveLocationMessage)
}

// optional .proto.Message.RequestPaymentMessage requestPaymentMessage = 22;
inline bool Message::_internal_has_requestpaymentmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestpaymentmessage_ != nullptr);
  return value;
}
inline bool Message::has_requestpaymentmessage() const {
  return _internal_has_requestpaymentmessage();
}
inline void Message::clear_requestpaymentmessage() {
  if (_impl_.requestpaymentmessage_ != nullptr) _impl_.requestpaymentmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::proto::Message_RequestPaymentMessage& Message::_internal_requestpaymentmessage() const {
  const ::proto::Message_RequestPaymentMessage* p = _impl_.requestpaymentmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestPaymentMessage&>(
      ::proto::_Message_RequestPaymentMessage_default_instance_);
}
inline const ::proto::Message_RequestPaymentMessage& Message::requestpaymentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.requestPaymentMessage)
  return _internal_requestpaymentmessage();
}
inline void Message::unsafe_arena_set_allocated_requestpaymentmessage(
    ::proto::Message_RequestPaymentMessage* requestpaymentmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestpaymentmessage_);
  }
  _impl_.requestpaymentmessage_ = requestpaymentmessage;
  if (requestpaymentmessage) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPaymentMessage)
}
inline ::proto::Message_RequestPaymentMessage* Message::release_requestpaymentmessage() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_;
  _impl_.requestpaymentmessage_ = 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 ::proto::Message_RequestPaymentMessage* Message::unsafe_arena_release_requestpaymentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.requestPaymentMessage)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::Message_RequestPaymentMessage* temp = _impl_.requestpaymentmessage_;
  _impl_.requestpaymentmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_RequestPaymentMessage* Message::_internal_mutable_requestpaymentmessage() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.requestpaymentmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_RequestPaymentMessage>(GetArenaForAllocation());
    _impl_.requestpaymentmessage_ = p;
  }
  return _impl_.requestpaymentmessage_;
}
inline ::proto::Message_RequestPaymentMessage* Message::mutable_requestpaymentmessage() {
  ::proto::Message_RequestPaymentMessage* _msg = _internal_mutable_requestpaymentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.requestPaymentMessage)
  return _msg;
}
inline void Message::set_allocated_requestpaymentmessage(::proto::Message_RequestPaymentMessage* requestpaymentmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestpaymentmessage_;
  }
  if (requestpaymentmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestpaymentmessage);
    if (message_arena != submessage_arena) {
      requestpaymentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestpaymentmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.requestpaymentmessage_ = requestpaymentmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPaymentMessage)
}

// optional .proto.Message.DeclinePaymentRequestMessage declinePaymentRequestMessage = 23;
inline bool Message::_internal_has_declinepaymentrequestmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.declinepaymentrequestmessage_ != nullptr);
  return value;
}
inline bool Message::has_declinepaymentrequestmessage() const {
  return _internal_has_declinepaymentrequestmessage();
}
inline void Message::clear_declinepaymentrequestmessage() {
  if (_impl_.declinepaymentrequestmessage_ != nullptr) _impl_.declinepaymentrequestmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::proto::Message_DeclinePaymentRequestMessage& Message::_internal_declinepaymentrequestmessage() const {
  const ::proto::Message_DeclinePaymentRequestMessage* p = _impl_.declinepaymentrequestmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DeclinePaymentRequestMessage&>(
      ::proto::_Message_DeclinePaymentRequestMessage_default_instance_);
}
inline const ::proto::Message_DeclinePaymentRequestMessage& Message::declinepaymentrequestmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.declinePaymentRequestMessage)
  return _internal_declinepaymentrequestmessage();
}
inline void Message::unsafe_arena_set_allocated_declinepaymentrequestmessage(
    ::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.declinepaymentrequestmessage_);
  }
  _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage;
  if (declinepaymentrequestmessage) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.declinePaymentRequestMessage)
}
inline ::proto::Message_DeclinePaymentRequestMessage* Message::release_declinepaymentrequestmessage() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_;
  _impl_.declinepaymentrequestmessage_ = 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 ::proto::Message_DeclinePaymentRequestMessage* Message::unsafe_arena_release_declinepaymentrequestmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.declinePaymentRequestMessage)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::Message_DeclinePaymentRequestMessage* temp = _impl_.declinepaymentrequestmessage_;
  _impl_.declinepaymentrequestmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_DeclinePaymentRequestMessage* Message::_internal_mutable_declinepaymentrequestmessage() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.declinepaymentrequestmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_DeclinePaymentRequestMessage>(GetArenaForAllocation());
    _impl_.declinepaymentrequestmessage_ = p;
  }
  return _impl_.declinepaymentrequestmessage_;
}
inline ::proto::Message_DeclinePaymentRequestMessage* Message::mutable_declinepaymentrequestmessage() {
  ::proto::Message_DeclinePaymentRequestMessage* _msg = _internal_mutable_declinepaymentrequestmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.declinePaymentRequestMessage)
  return _msg;
}
inline void Message::set_allocated_declinepaymentrequestmessage(::proto::Message_DeclinePaymentRequestMessage* declinepaymentrequestmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.declinepaymentrequestmessage_;
  }
  if (declinepaymentrequestmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(declinepaymentrequestmessage);
    if (message_arena != submessage_arena) {
      declinepaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, declinepaymentrequestmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.declinepaymentrequestmessage_ = declinepaymentrequestmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.declinePaymentRequestMessage)
}

// optional .proto.Message.CancelPaymentRequestMessage cancelPaymentRequestMessage = 24;
inline bool Message::_internal_has_cancelpaymentrequestmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cancelpaymentrequestmessage_ != nullptr);
  return value;
}
inline bool Message::has_cancelpaymentrequestmessage() const {
  return _internal_has_cancelpaymentrequestmessage();
}
inline void Message::clear_cancelpaymentrequestmessage() {
  if (_impl_.cancelpaymentrequestmessage_ != nullptr) _impl_.cancelpaymentrequestmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const ::proto::Message_CancelPaymentRequestMessage& Message::_internal_cancelpaymentrequestmessage() const {
  const ::proto::Message_CancelPaymentRequestMessage* p = _impl_.cancelpaymentrequestmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_CancelPaymentRequestMessage&>(
      ::proto::_Message_CancelPaymentRequestMessage_default_instance_);
}
inline const ::proto::Message_CancelPaymentRequestMessage& Message::cancelpaymentrequestmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.cancelPaymentRequestMessage)
  return _internal_cancelpaymentrequestmessage();
}
inline void Message::unsafe_arena_set_allocated_cancelpaymentrequestmessage(
    ::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cancelpaymentrequestmessage_);
  }
  _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage;
  if (cancelpaymentrequestmessage) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.cancelPaymentRequestMessage)
}
inline ::proto::Message_CancelPaymentRequestMessage* Message::release_cancelpaymentrequestmessage() {
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_;
  _impl_.cancelpaymentrequestmessage_ = 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 ::proto::Message_CancelPaymentRequestMessage* Message::unsafe_arena_release_cancelpaymentrequestmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.cancelPaymentRequestMessage)
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::proto::Message_CancelPaymentRequestMessage* temp = _impl_.cancelpaymentrequestmessage_;
  _impl_.cancelpaymentrequestmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_CancelPaymentRequestMessage* Message::_internal_mutable_cancelpaymentrequestmessage() {
  _impl_._has_bits_[0] |= 0x00080000u;
  if (_impl_.cancelpaymentrequestmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_CancelPaymentRequestMessage>(GetArenaForAllocation());
    _impl_.cancelpaymentrequestmessage_ = p;
  }
  return _impl_.cancelpaymentrequestmessage_;
}
inline ::proto::Message_CancelPaymentRequestMessage* Message::mutable_cancelpaymentrequestmessage() {
  ::proto::Message_CancelPaymentRequestMessage* _msg = _internal_mutable_cancelpaymentrequestmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.cancelPaymentRequestMessage)
  return _msg;
}
inline void Message::set_allocated_cancelpaymentrequestmessage(::proto::Message_CancelPaymentRequestMessage* cancelpaymentrequestmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.cancelpaymentrequestmessage_;
  }
  if (cancelpaymentrequestmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cancelpaymentrequestmessage);
    if (message_arena != submessage_arena) {
      cancelpaymentrequestmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cancelpaymentrequestmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.cancelpaymentrequestmessage_ = cancelpaymentrequestmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.cancelPaymentRequestMessage)
}

// optional .proto.Message.TemplateMessage templateMessage = 25;
inline bool Message::_internal_has_templatemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.templatemessage_ != nullptr);
  return value;
}
inline bool Message::has_templatemessage() const {
  return _internal_has_templatemessage();
}
inline void Message::clear_templatemessage() {
  if (_impl_.templatemessage_ != nullptr) _impl_.templatemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const ::proto::Message_TemplateMessage& Message::_internal_templatemessage() const {
  const ::proto::Message_TemplateMessage* p = _impl_.templatemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateMessage&>(
      ::proto::_Message_TemplateMessage_default_instance_);
}
inline const ::proto::Message_TemplateMessage& Message::templatemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.templateMessage)
  return _internal_templatemessage();
}
inline void Message::unsafe_arena_set_allocated_templatemessage(
    ::proto::Message_TemplateMessage* templatemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatemessage_);
  }
  _impl_.templatemessage_ = templatemessage;
  if (templatemessage) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateMessage)
}
inline ::proto::Message_TemplateMessage* Message::release_templatemessage() {
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_;
  _impl_.templatemessage_ = 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 ::proto::Message_TemplateMessage* Message::unsafe_arena_release_templatemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.templateMessage)
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::proto::Message_TemplateMessage* temp = _impl_.templatemessage_;
  _impl_.templatemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_TemplateMessage* Message::_internal_mutable_templatemessage() {
  _impl_._has_bits_[0] |= 0x00100000u;
  if (_impl_.templatemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_TemplateMessage>(GetArenaForAllocation());
    _impl_.templatemessage_ = p;
  }
  return _impl_.templatemessage_;
}
inline ::proto::Message_TemplateMessage* Message::mutable_templatemessage() {
  ::proto::Message_TemplateMessage* _msg = _internal_mutable_templatemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.templateMessage)
  return _msg;
}
inline void Message::set_allocated_templatemessage(::proto::Message_TemplateMessage* templatemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.templatemessage_;
  }
  if (templatemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatemessage);
    if (message_arena != submessage_arena) {
      templatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, templatemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.templatemessage_ = templatemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.templateMessage)
}

// optional .proto.Message.StickerMessage stickerMessage = 26;
inline bool Message::_internal_has_stickermessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stickermessage_ != nullptr);
  return value;
}
inline bool Message::has_stickermessage() const {
  return _internal_has_stickermessage();
}
inline void Message::clear_stickermessage() {
  if (_impl_.stickermessage_ != nullptr) _impl_.stickermessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const ::proto::Message_StickerMessage& Message::_internal_stickermessage() const {
  const ::proto::Message_StickerMessage* p = _impl_.stickermessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerMessage&>(
      ::proto::_Message_StickerMessage_default_instance_);
}
inline const ::proto::Message_StickerMessage& Message::stickermessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.stickerMessage)
  return _internal_stickermessage();
}
inline void Message::unsafe_arena_set_allocated_stickermessage(
    ::proto::Message_StickerMessage* stickermessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickermessage_);
  }
  _impl_.stickermessage_ = stickermessage;
  if (stickermessage) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerMessage)
}
inline ::proto::Message_StickerMessage* Message::release_stickermessage() {
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
  _impl_.stickermessage_ = 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 ::proto::Message_StickerMessage* Message::unsafe_arena_release_stickermessage() {
  // @@protoc_insertion_point(field_release:proto.Message.stickerMessage)
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::proto::Message_StickerMessage* temp = _impl_.stickermessage_;
  _impl_.stickermessage_ = nullptr;
  return temp;
}
inline ::proto::Message_StickerMessage* Message::_internal_mutable_stickermessage() {
  _impl_._has_bits_[0] |= 0x00200000u;
  if (_impl_.stickermessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_StickerMessage>(GetArenaForAllocation());
    _impl_.stickermessage_ = p;
  }
  return _impl_.stickermessage_;
}
inline ::proto::Message_StickerMessage* Message::mutable_stickermessage() {
  ::proto::Message_StickerMessage* _msg = _internal_mutable_stickermessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.stickerMessage)
  return _msg;
}
inline void Message::set_allocated_stickermessage(::proto::Message_StickerMessage* stickermessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stickermessage_;
  }
  if (stickermessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickermessage);
    if (message_arena != submessage_arena) {
      stickermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stickermessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.stickermessage_ = stickermessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerMessage)
}

// optional .proto.Message.GroupInviteMessage groupInviteMessage = 28;
inline bool Message::_internal_has_groupinvitemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.groupinvitemessage_ != nullptr);
  return value;
}
inline bool Message::has_groupinvitemessage() const {
  return _internal_has_groupinvitemessage();
}
inline void Message::clear_groupinvitemessage() {
  if (_impl_.groupinvitemessage_ != nullptr) _impl_.groupinvitemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline const ::proto::Message_GroupInviteMessage& Message::_internal_groupinvitemessage() const {
  const ::proto::Message_GroupInviteMessage* p = _impl_.groupinvitemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_GroupInviteMessage&>(
      ::proto::_Message_GroupInviteMessage_default_instance_);
}
inline const ::proto::Message_GroupInviteMessage& Message::groupinvitemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.groupInviteMessage)
  return _internal_groupinvitemessage();
}
inline void Message::unsafe_arena_set_allocated_groupinvitemessage(
    ::proto::Message_GroupInviteMessage* groupinvitemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.groupinvitemessage_);
  }
  _impl_.groupinvitemessage_ = groupinvitemessage;
  if (groupinvitemessage) {
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.groupInviteMessage)
}
inline ::proto::Message_GroupInviteMessage* Message::release_groupinvitemessage() {
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_;
  _impl_.groupinvitemessage_ = 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 ::proto::Message_GroupInviteMessage* Message::unsafe_arena_release_groupinvitemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.groupInviteMessage)
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::proto::Message_GroupInviteMessage* temp = _impl_.groupinvitemessage_;
  _impl_.groupinvitemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_GroupInviteMessage* Message::_internal_mutable_groupinvitemessage() {
  _impl_._has_bits_[0] |= 0x00400000u;
  if (_impl_.groupinvitemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_GroupInviteMessage>(GetArenaForAllocation());
    _impl_.groupinvitemessage_ = p;
  }
  return _impl_.groupinvitemessage_;
}
inline ::proto::Message_GroupInviteMessage* Message::mutable_groupinvitemessage() {
  ::proto::Message_GroupInviteMessage* _msg = _internal_mutable_groupinvitemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.groupInviteMessage)
  return _msg;
}
inline void Message::set_allocated_groupinvitemessage(::proto::Message_GroupInviteMessage* groupinvitemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.groupinvitemessage_;
  }
  if (groupinvitemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(groupinvitemessage);
    if (message_arena != submessage_arena) {
      groupinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, groupinvitemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  _impl_.groupinvitemessage_ = groupinvitemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.groupInviteMessage)
}

// optional .proto.Message.TemplateButtonReplyMessage templateButtonReplyMessage = 29;
inline bool Message::_internal_has_templatebuttonreplymessage() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.templatebuttonreplymessage_ != nullptr);
  return value;
}
inline bool Message::has_templatebuttonreplymessage() const {
  return _internal_has_templatebuttonreplymessage();
}
inline void Message::clear_templatebuttonreplymessage() {
  if (_impl_.templatebuttonreplymessage_ != nullptr) _impl_.templatebuttonreplymessage_->Clear();
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline const ::proto::Message_TemplateButtonReplyMessage& Message::_internal_templatebuttonreplymessage() const {
  const ::proto::Message_TemplateButtonReplyMessage* p = _impl_.templatebuttonreplymessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_TemplateButtonReplyMessage&>(
      ::proto::_Message_TemplateButtonReplyMessage_default_instance_);
}
inline const ::proto::Message_TemplateButtonReplyMessage& Message::templatebuttonreplymessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.templateButtonReplyMessage)
  return _internal_templatebuttonreplymessage();
}
inline void Message::unsafe_arena_set_allocated_templatebuttonreplymessage(
    ::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.templatebuttonreplymessage_);
  }
  _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage;
  if (templatebuttonreplymessage) {
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.templateButtonReplyMessage)
}
inline ::proto::Message_TemplateButtonReplyMessage* Message::release_templatebuttonreplymessage() {
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_;
  _impl_.templatebuttonreplymessage_ = 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 ::proto::Message_TemplateButtonReplyMessage* Message::unsafe_arena_release_templatebuttonreplymessage() {
  // @@protoc_insertion_point(field_release:proto.Message.templateButtonReplyMessage)
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::proto::Message_TemplateButtonReplyMessage* temp = _impl_.templatebuttonreplymessage_;
  _impl_.templatebuttonreplymessage_ = nullptr;
  return temp;
}
inline ::proto::Message_TemplateButtonReplyMessage* Message::_internal_mutable_templatebuttonreplymessage() {
  _impl_._has_bits_[0] |= 0x00800000u;
  if (_impl_.templatebuttonreplymessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_TemplateButtonReplyMessage>(GetArenaForAllocation());
    _impl_.templatebuttonreplymessage_ = p;
  }
  return _impl_.templatebuttonreplymessage_;
}
inline ::proto::Message_TemplateButtonReplyMessage* Message::mutable_templatebuttonreplymessage() {
  ::proto::Message_TemplateButtonReplyMessage* _msg = _internal_mutable_templatebuttonreplymessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.templateButtonReplyMessage)
  return _msg;
}
inline void Message::set_allocated_templatebuttonreplymessage(::proto::Message_TemplateButtonReplyMessage* templatebuttonreplymessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.templatebuttonreplymessage_;
  }
  if (templatebuttonreplymessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(templatebuttonreplymessage);
    if (message_arena != submessage_arena) {
      templatebuttonreplymessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, templatebuttonreplymessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  _impl_.templatebuttonreplymessage_ = templatebuttonreplymessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.templateButtonReplyMessage)
}

// optional .proto.Message.ProductMessage productMessage = 30;
inline bool Message::_internal_has_productmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.productmessage_ != nullptr);
  return value;
}
inline bool Message::has_productmessage() const {
  return _internal_has_productmessage();
}
inline void Message::clear_productmessage() {
  if (_impl_.productmessage_ != nullptr) _impl_.productmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline const ::proto::Message_ProductMessage& Message::_internal_productmessage() const {
  const ::proto::Message_ProductMessage* p = _impl_.productmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ProductMessage&>(
      ::proto::_Message_ProductMessage_default_instance_);
}
inline const ::proto::Message_ProductMessage& Message::productmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.productMessage)
  return _internal_productmessage();
}
inline void Message::unsafe_arena_set_allocated_productmessage(
    ::proto::Message_ProductMessage* productmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.productmessage_);
  }
  _impl_.productmessage_ = productmessage;
  if (productmessage) {
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.productMessage)
}
inline ::proto::Message_ProductMessage* Message::release_productmessage() {
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::proto::Message_ProductMessage* temp = _impl_.productmessage_;
  _impl_.productmessage_ = 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 ::proto::Message_ProductMessage* Message::unsafe_arena_release_productmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.productMessage)
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::proto::Message_ProductMessage* temp = _impl_.productmessage_;
  _impl_.productmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ProductMessage* Message::_internal_mutable_productmessage() {
  _impl_._has_bits_[0] |= 0x01000000u;
  if (_impl_.productmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ProductMessage>(GetArenaForAllocation());
    _impl_.productmessage_ = p;
  }
  return _impl_.productmessage_;
}
inline ::proto::Message_ProductMessage* Message::mutable_productmessage() {
  ::proto::Message_ProductMessage* _msg = _internal_mutable_productmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.productMessage)
  return _msg;
}
inline void Message::set_allocated_productmessage(::proto::Message_ProductMessage* productmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.productmessage_;
  }
  if (productmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(productmessage);
    if (message_arena != submessage_arena) {
      productmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, productmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  _impl_.productmessage_ = productmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.productMessage)
}

// optional .proto.Message.DeviceSentMessage deviceSentMessage = 31;
inline bool Message::_internal_has_devicesentmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.devicesentmessage_ != nullptr);
  return value;
}
inline bool Message::has_devicesentmessage() const {
  return _internal_has_devicesentmessage();
}
inline void Message::clear_devicesentmessage() {
  if (_impl_.devicesentmessage_ != nullptr) _impl_.devicesentmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline const ::proto::Message_DeviceSentMessage& Message::_internal_devicesentmessage() const {
  const ::proto::Message_DeviceSentMessage* p = _impl_.devicesentmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_DeviceSentMessage&>(
      ::proto::_Message_DeviceSentMessage_default_instance_);
}
inline const ::proto::Message_DeviceSentMessage& Message::devicesentmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.deviceSentMessage)
  return _internal_devicesentmessage();
}
inline void Message::unsafe_arena_set_allocated_devicesentmessage(
    ::proto::Message_DeviceSentMessage* devicesentmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicesentmessage_);
  }
  _impl_.devicesentmessage_ = devicesentmessage;
  if (devicesentmessage) {
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.deviceSentMessage)
}
inline ::proto::Message_DeviceSentMessage* Message::release_devicesentmessage() {
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_;
  _impl_.devicesentmessage_ = 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 ::proto::Message_DeviceSentMessage* Message::unsafe_arena_release_devicesentmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.deviceSentMessage)
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::proto::Message_DeviceSentMessage* temp = _impl_.devicesentmessage_;
  _impl_.devicesentmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_DeviceSentMessage* Message::_internal_mutable_devicesentmessage() {
  _impl_._has_bits_[0] |= 0x02000000u;
  if (_impl_.devicesentmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_DeviceSentMessage>(GetArenaForAllocation());
    _impl_.devicesentmessage_ = p;
  }
  return _impl_.devicesentmessage_;
}
inline ::proto::Message_DeviceSentMessage* Message::mutable_devicesentmessage() {
  ::proto::Message_DeviceSentMessage* _msg = _internal_mutable_devicesentmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.deviceSentMessage)
  return _msg;
}
inline void Message::set_allocated_devicesentmessage(::proto::Message_DeviceSentMessage* devicesentmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.devicesentmessage_;
  }
  if (devicesentmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicesentmessage);
    if (message_arena != submessage_arena) {
      devicesentmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, devicesentmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  _impl_.devicesentmessage_ = devicesentmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.deviceSentMessage)
}

// optional .proto.MessageContextInfo messageContextInfo = 35;
inline bool Message::_internal_has_messagecontextinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagecontextinfo_ != nullptr);
  return value;
}
inline bool Message::has_messagecontextinfo() const {
  return _internal_has_messagecontextinfo();
}
inline void Message::clear_messagecontextinfo() {
  if (_impl_.messagecontextinfo_ != nullptr) _impl_.messagecontextinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline const ::proto::MessageContextInfo& Message::_internal_messagecontextinfo() const {
  const ::proto::MessageContextInfo* p = _impl_.messagecontextinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageContextInfo&>(
      ::proto::_MessageContextInfo_default_instance_);
}
inline const ::proto::MessageContextInfo& Message::messagecontextinfo() const {
  // @@protoc_insertion_point(field_get:proto.Message.messageContextInfo)
  return _internal_messagecontextinfo();
}
inline void Message::unsafe_arena_set_allocated_messagecontextinfo(
    ::proto::MessageContextInfo* messagecontextinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagecontextinfo_);
  }
  _impl_.messagecontextinfo_ = messagecontextinfo;
  if (messagecontextinfo) {
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.messageContextInfo)
}
inline ::proto::MessageContextInfo* Message::release_messagecontextinfo() {
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_;
  _impl_.messagecontextinfo_ = 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 ::proto::MessageContextInfo* Message::unsafe_arena_release_messagecontextinfo() {
  // @@protoc_insertion_point(field_release:proto.Message.messageContextInfo)
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::proto::MessageContextInfo* temp = _impl_.messagecontextinfo_;
  _impl_.messagecontextinfo_ = nullptr;
  return temp;
}
inline ::proto::MessageContextInfo* Message::_internal_mutable_messagecontextinfo() {
  _impl_._has_bits_[0] |= 0x04000000u;
  if (_impl_.messagecontextinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageContextInfo>(GetArenaForAllocation());
    _impl_.messagecontextinfo_ = p;
  }
  return _impl_.messagecontextinfo_;
}
inline ::proto::MessageContextInfo* Message::mutable_messagecontextinfo() {
  ::proto::MessageContextInfo* _msg = _internal_mutable_messagecontextinfo();
  // @@protoc_insertion_point(field_mutable:proto.Message.messageContextInfo)
  return _msg;
}
inline void Message::set_allocated_messagecontextinfo(::proto::MessageContextInfo* messagecontextinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagecontextinfo_;
  }
  if (messagecontextinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagecontextinfo);
    if (message_arena != submessage_arena) {
      messagecontextinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagecontextinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  _impl_.messagecontextinfo_ = messagecontextinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.messageContextInfo)
}

// optional .proto.Message.ListMessage listMessage = 36;
inline bool Message::_internal_has_listmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.listmessage_ != nullptr);
  return value;
}
inline bool Message::has_listmessage() const {
  return _internal_has_listmessage();
}
inline void Message::clear_listmessage() {
  if (_impl_.listmessage_ != nullptr) _impl_.listmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline const ::proto::Message_ListMessage& Message::_internal_listmessage() const {
  const ::proto::Message_ListMessage* p = _impl_.listmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListMessage&>(
      ::proto::_Message_ListMessage_default_instance_);
}
inline const ::proto::Message_ListMessage& Message::listmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.listMessage)
  return _internal_listmessage();
}
inline void Message::unsafe_arena_set_allocated_listmessage(
    ::proto::Message_ListMessage* listmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listmessage_);
  }
  _impl_.listmessage_ = listmessage;
  if (listmessage) {
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listMessage)
}
inline ::proto::Message_ListMessage* Message::release_listmessage() {
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::proto::Message_ListMessage* temp = _impl_.listmessage_;
  _impl_.listmessage_ = 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 ::proto::Message_ListMessage* Message::unsafe_arena_release_listmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.listMessage)
  _impl_._has_bits_[0] &= ~0x08000000u;
  ::proto::Message_ListMessage* temp = _impl_.listmessage_;
  _impl_.listmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ListMessage* Message::_internal_mutable_listmessage() {
  _impl_._has_bits_[0] |= 0x08000000u;
  if (_impl_.listmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ListMessage>(GetArenaForAllocation());
    _impl_.listmessage_ = p;
  }
  return _impl_.listmessage_;
}
inline ::proto::Message_ListMessage* Message::mutable_listmessage() {
  ::proto::Message_ListMessage* _msg = _internal_mutable_listmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.listMessage)
  return _msg;
}
inline void Message::set_allocated_listmessage(::proto::Message_ListMessage* listmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.listmessage_;
  }
  if (listmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listmessage);
    if (message_arena != submessage_arena) {
      listmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, listmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x08000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x08000000u;
  }
  _impl_.listmessage_ = listmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.listMessage)
}

// optional .proto.Message.FutureProofMessage viewOnceMessage = 37;
inline bool Message::_internal_has_viewoncemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.viewoncemessage_ != nullptr);
  return value;
}
inline bool Message::has_viewoncemessage() const {
  return _internal_has_viewoncemessage();
}
inline void Message::clear_viewoncemessage() {
  if (_impl_.viewoncemessage_ != nullptr) _impl_.viewoncemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessage() const {
  const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
      ::proto::_Message_FutureProofMessage_default_instance_);
}
inline const ::proto::Message_FutureProofMessage& Message::viewoncemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessage)
  return _internal_viewoncemessage();
}
inline void Message::unsafe_arena_set_allocated_viewoncemessage(
    ::proto::Message_FutureProofMessage* viewoncemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessage_);
  }
  _impl_.viewoncemessage_ = viewoncemessage;
  if (viewoncemessage) {
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessage)
}
inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessage() {
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_;
  _impl_.viewoncemessage_ = 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 ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessage)
  _impl_._has_bits_[0] &= ~0x10000000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessage_;
  _impl_.viewoncemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessage() {
  _impl_._has_bits_[0] |= 0x10000000u;
  if (_impl_.viewoncemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
    _impl_.viewoncemessage_ = p;
  }
  return _impl_.viewoncemessage_;
}
inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessage() {
  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessage)
  return _msg;
}
inline void Message::set_allocated_viewoncemessage(::proto::Message_FutureProofMessage* viewoncemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.viewoncemessage_;
  }
  if (viewoncemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessage);
    if (message_arena != submessage_arena) {
      viewoncemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, viewoncemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x10000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x10000000u;
  }
  _impl_.viewoncemessage_ = viewoncemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessage)
}

// optional .proto.Message.OrderMessage orderMessage = 38;
inline bool Message::_internal_has_ordermessage() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ordermessage_ != nullptr);
  return value;
}
inline bool Message::has_ordermessage() const {
  return _internal_has_ordermessage();
}
inline void Message::clear_ordermessage() {
  if (_impl_.ordermessage_ != nullptr) _impl_.ordermessage_->Clear();
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline const ::proto::Message_OrderMessage& Message::_internal_ordermessage() const {
  const ::proto::Message_OrderMessage* p = _impl_.ordermessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_OrderMessage&>(
      ::proto::_Message_OrderMessage_default_instance_);
}
inline const ::proto::Message_OrderMessage& Message::ordermessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.orderMessage)
  return _internal_ordermessage();
}
inline void Message::unsafe_arena_set_allocated_ordermessage(
    ::proto::Message_OrderMessage* ordermessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ordermessage_);
  }
  _impl_.ordermessage_ = ordermessage;
  if (ordermessage) {
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.orderMessage)
}
inline ::proto::Message_OrderMessage* Message::release_ordermessage() {
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::proto::Message_OrderMessage* temp = _impl_.ordermessage_;
  _impl_.ordermessage_ = 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 ::proto::Message_OrderMessage* Message::unsafe_arena_release_ordermessage() {
  // @@protoc_insertion_point(field_release:proto.Message.orderMessage)
  _impl_._has_bits_[0] &= ~0x20000000u;
  ::proto::Message_OrderMessage* temp = _impl_.ordermessage_;
  _impl_.ordermessage_ = nullptr;
  return temp;
}
inline ::proto::Message_OrderMessage* Message::_internal_mutable_ordermessage() {
  _impl_._has_bits_[0] |= 0x20000000u;
  if (_impl_.ordermessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_OrderMessage>(GetArenaForAllocation());
    _impl_.ordermessage_ = p;
  }
  return _impl_.ordermessage_;
}
inline ::proto::Message_OrderMessage* Message::mutable_ordermessage() {
  ::proto::Message_OrderMessage* _msg = _internal_mutable_ordermessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.orderMessage)
  return _msg;
}
inline void Message::set_allocated_ordermessage(::proto::Message_OrderMessage* ordermessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ordermessage_;
  }
  if (ordermessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ordermessage);
    if (message_arena != submessage_arena) {
      ordermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ordermessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x20000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x20000000u;
  }
  _impl_.ordermessage_ = ordermessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.orderMessage)
}

// optional .proto.Message.ListResponseMessage listResponseMessage = 39;
inline bool Message::_internal_has_listresponsemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.listresponsemessage_ != nullptr);
  return value;
}
inline bool Message::has_listresponsemessage() const {
  return _internal_has_listresponsemessage();
}
inline void Message::clear_listresponsemessage() {
  if (_impl_.listresponsemessage_ != nullptr) _impl_.listresponsemessage_->Clear();
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline const ::proto::Message_ListResponseMessage& Message::_internal_listresponsemessage() const {
  const ::proto::Message_ListResponseMessage* p = _impl_.listresponsemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ListResponseMessage&>(
      ::proto::_Message_ListResponseMessage_default_instance_);
}
inline const ::proto::Message_ListResponseMessage& Message::listresponsemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.listResponseMessage)
  return _internal_listresponsemessage();
}
inline void Message::unsafe_arena_set_allocated_listresponsemessage(
    ::proto::Message_ListResponseMessage* listresponsemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.listresponsemessage_);
  }
  _impl_.listresponsemessage_ = listresponsemessage;
  if (listresponsemessage) {
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.listResponseMessage)
}
inline ::proto::Message_ListResponseMessage* Message::release_listresponsemessage() {
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_;
  _impl_.listresponsemessage_ = 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 ::proto::Message_ListResponseMessage* Message::unsafe_arena_release_listresponsemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.listResponseMessage)
  _impl_._has_bits_[0] &= ~0x40000000u;
  ::proto::Message_ListResponseMessage* temp = _impl_.listresponsemessage_;
  _impl_.listresponsemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ListResponseMessage* Message::_internal_mutable_listresponsemessage() {
  _impl_._has_bits_[0] |= 0x40000000u;
  if (_impl_.listresponsemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ListResponseMessage>(GetArenaForAllocation());
    _impl_.listresponsemessage_ = p;
  }
  return _impl_.listresponsemessage_;
}
inline ::proto::Message_ListResponseMessage* Message::mutable_listresponsemessage() {
  ::proto::Message_ListResponseMessage* _msg = _internal_mutable_listresponsemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.listResponseMessage)
  return _msg;
}
inline void Message::set_allocated_listresponsemessage(::proto::Message_ListResponseMessage* listresponsemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.listresponsemessage_;
  }
  if (listresponsemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(listresponsemessage);
    if (message_arena != submessage_arena) {
      listresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, listresponsemessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x40000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x40000000u;
  }
  _impl_.listresponsemessage_ = listresponsemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.listResponseMessage)
}

// optional .proto.Message.FutureProofMessage ephemeralMessage = 40;
inline bool Message::_internal_has_ephemeralmessage() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ephemeralmessage_ != nullptr);
  return value;
}
inline bool Message::has_ephemeralmessage() const {
  return _internal_has_ephemeralmessage();
}
inline void Message::clear_ephemeralmessage() {
  if (_impl_.ephemeralmessage_ != nullptr) _impl_.ephemeralmessage_->Clear();
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline const ::proto::Message_FutureProofMessage& Message::_internal_ephemeralmessage() const {
  const ::proto::Message_FutureProofMessage* p = _impl_.ephemeralmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
      ::proto::_Message_FutureProofMessage_default_instance_);
}
inline const ::proto::Message_FutureProofMessage& Message::ephemeralmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.ephemeralMessage)
  return _internal_ephemeralmessage();
}
inline void Message::unsafe_arena_set_allocated_ephemeralmessage(
    ::proto::Message_FutureProofMessage* ephemeralmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ephemeralmessage_);
  }
  _impl_.ephemeralmessage_ = ephemeralmessage;
  if (ephemeralmessage) {
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.ephemeralMessage)
}
inline ::proto::Message_FutureProofMessage* Message::release_ephemeralmessage() {
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_;
  _impl_.ephemeralmessage_ = 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 ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_ephemeralmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.ephemeralMessage)
  _impl_._has_bits_[0] &= ~0x80000000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.ephemeralmessage_;
  _impl_.ephemeralmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_ephemeralmessage() {
  _impl_._has_bits_[0] |= 0x80000000u;
  if (_impl_.ephemeralmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
    _impl_.ephemeralmessage_ = p;
  }
  return _impl_.ephemeralmessage_;
}
inline ::proto::Message_FutureProofMessage* Message::mutable_ephemeralmessage() {
  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_ephemeralmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.ephemeralMessage)
  return _msg;
}
inline void Message::set_allocated_ephemeralmessage(::proto::Message_FutureProofMessage* ephemeralmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ephemeralmessage_;
  }
  if (ephemeralmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ephemeralmessage);
    if (message_arena != submessage_arena) {
      ephemeralmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ephemeralmessage, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x80000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x80000000u;
  }
  _impl_.ephemeralmessage_ = ephemeralmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.ephemeralMessage)
}

// optional .proto.Message.InvoiceMessage invoiceMessage = 41;
inline bool Message::_internal_has_invoicemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.invoicemessage_ != nullptr);
  return value;
}
inline bool Message::has_invoicemessage() const {
  return _internal_has_invoicemessage();
}
inline void Message::clear_invoicemessage() {
  if (_impl_.invoicemessage_ != nullptr) _impl_.invoicemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline const ::proto::Message_InvoiceMessage& Message::_internal_invoicemessage() const {
  const ::proto::Message_InvoiceMessage* p = _impl_.invoicemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InvoiceMessage&>(
      ::proto::_Message_InvoiceMessage_default_instance_);
}
inline const ::proto::Message_InvoiceMessage& Message::invoicemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.invoiceMessage)
  return _internal_invoicemessage();
}
inline void Message::unsafe_arena_set_allocated_invoicemessage(
    ::proto::Message_InvoiceMessage* invoicemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.invoicemessage_);
  }
  _impl_.invoicemessage_ = invoicemessage;
  if (invoicemessage) {
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.invoiceMessage)
}
inline ::proto::Message_InvoiceMessage* Message::release_invoicemessage() {
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_;
  _impl_.invoicemessage_ = 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 ::proto::Message_InvoiceMessage* Message::unsafe_arena_release_invoicemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.invoiceMessage)
  _impl_._has_bits_[1] &= ~0x00000001u;
  ::proto::Message_InvoiceMessage* temp = _impl_.invoicemessage_;
  _impl_.invoicemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_InvoiceMessage* Message::_internal_mutable_invoicemessage() {
  _impl_._has_bits_[1] |= 0x00000001u;
  if (_impl_.invoicemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InvoiceMessage>(GetArenaForAllocation());
    _impl_.invoicemessage_ = p;
  }
  return _impl_.invoicemessage_;
}
inline ::proto::Message_InvoiceMessage* Message::mutable_invoicemessage() {
  ::proto::Message_InvoiceMessage* _msg = _internal_mutable_invoicemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.invoiceMessage)
  return _msg;
}
inline void Message::set_allocated_invoicemessage(::proto::Message_InvoiceMessage* invoicemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.invoicemessage_;
  }
  if (invoicemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(invoicemessage);
    if (message_arena != submessage_arena) {
      invoicemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, invoicemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000001u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000001u;
  }
  _impl_.invoicemessage_ = invoicemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.invoiceMessage)
}

// optional .proto.Message.ButtonsMessage buttonsMessage = 42;
inline bool Message::_internal_has_buttonsmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.buttonsmessage_ != nullptr);
  return value;
}
inline bool Message::has_buttonsmessage() const {
  return _internal_has_buttonsmessage();
}
inline void Message::clear_buttonsmessage() {
  if (_impl_.buttonsmessage_ != nullptr) _impl_.buttonsmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline const ::proto::Message_ButtonsMessage& Message::_internal_buttonsmessage() const {
  const ::proto::Message_ButtonsMessage* p = _impl_.buttonsmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsMessage&>(
      ::proto::_Message_ButtonsMessage_default_instance_);
}
inline const ::proto::Message_ButtonsMessage& Message::buttonsmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.buttonsMessage)
  return _internal_buttonsmessage();
}
inline void Message::unsafe_arena_set_allocated_buttonsmessage(
    ::proto::Message_ButtonsMessage* buttonsmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsmessage_);
  }
  _impl_.buttonsmessage_ = buttonsmessage;
  if (buttonsmessage) {
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsMessage)
}
inline ::proto::Message_ButtonsMessage* Message::release_buttonsmessage() {
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_;
  _impl_.buttonsmessage_ = 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 ::proto::Message_ButtonsMessage* Message::unsafe_arena_release_buttonsmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.buttonsMessage)
  _impl_._has_bits_[1] &= ~0x00000002u;
  ::proto::Message_ButtonsMessage* temp = _impl_.buttonsmessage_;
  _impl_.buttonsmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ButtonsMessage* Message::_internal_mutable_buttonsmessage() {
  _impl_._has_bits_[1] |= 0x00000002u;
  if (_impl_.buttonsmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ButtonsMessage>(GetArenaForAllocation());
    _impl_.buttonsmessage_ = p;
  }
  return _impl_.buttonsmessage_;
}
inline ::proto::Message_ButtonsMessage* Message::mutable_buttonsmessage() {
  ::proto::Message_ButtonsMessage* _msg = _internal_mutable_buttonsmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.buttonsMessage)
  return _msg;
}
inline void Message::set_allocated_buttonsmessage(::proto::Message_ButtonsMessage* buttonsmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.buttonsmessage_;
  }
  if (buttonsmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsmessage);
    if (message_arena != submessage_arena) {
      buttonsmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buttonsmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000002u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000002u;
  }
  _impl_.buttonsmessage_ = buttonsmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsMessage)
}

// optional .proto.Message.ButtonsResponseMessage buttonsResponseMessage = 43;
inline bool Message::_internal_has_buttonsresponsemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.buttonsresponsemessage_ != nullptr);
  return value;
}
inline bool Message::has_buttonsresponsemessage() const {
  return _internal_has_buttonsresponsemessage();
}
inline void Message::clear_buttonsresponsemessage() {
  if (_impl_.buttonsresponsemessage_ != nullptr) _impl_.buttonsresponsemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline const ::proto::Message_ButtonsResponseMessage& Message::_internal_buttonsresponsemessage() const {
  const ::proto::Message_ButtonsResponseMessage* p = _impl_.buttonsresponsemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ButtonsResponseMessage&>(
      ::proto::_Message_ButtonsResponseMessage_default_instance_);
}
inline const ::proto::Message_ButtonsResponseMessage& Message::buttonsresponsemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.buttonsResponseMessage)
  return _internal_buttonsresponsemessage();
}
inline void Message::unsafe_arena_set_allocated_buttonsresponsemessage(
    ::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.buttonsresponsemessage_);
  }
  _impl_.buttonsresponsemessage_ = buttonsresponsemessage;
  if (buttonsresponsemessage) {
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.buttonsResponseMessage)
}
inline ::proto::Message_ButtonsResponseMessage* Message::release_buttonsresponsemessage() {
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_;
  _impl_.buttonsresponsemessage_ = 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 ::proto::Message_ButtonsResponseMessage* Message::unsafe_arena_release_buttonsresponsemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.buttonsResponseMessage)
  _impl_._has_bits_[1] &= ~0x00000004u;
  ::proto::Message_ButtonsResponseMessage* temp = _impl_.buttonsresponsemessage_;
  _impl_.buttonsresponsemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ButtonsResponseMessage* Message::_internal_mutable_buttonsresponsemessage() {
  _impl_._has_bits_[1] |= 0x00000004u;
  if (_impl_.buttonsresponsemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ButtonsResponseMessage>(GetArenaForAllocation());
    _impl_.buttonsresponsemessage_ = p;
  }
  return _impl_.buttonsresponsemessage_;
}
inline ::proto::Message_ButtonsResponseMessage* Message::mutable_buttonsresponsemessage() {
  ::proto::Message_ButtonsResponseMessage* _msg = _internal_mutable_buttonsresponsemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.buttonsResponseMessage)
  return _msg;
}
inline void Message::set_allocated_buttonsresponsemessage(::proto::Message_ButtonsResponseMessage* buttonsresponsemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.buttonsresponsemessage_;
  }
  if (buttonsresponsemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(buttonsresponsemessage);
    if (message_arena != submessage_arena) {
      buttonsresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, buttonsresponsemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000004u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000004u;
  }
  _impl_.buttonsresponsemessage_ = buttonsresponsemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.buttonsResponseMessage)
}

// optional .proto.Message.PaymentInviteMessage paymentInviteMessage = 44;
inline bool Message::_internal_has_paymentinvitemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.paymentinvitemessage_ != nullptr);
  return value;
}
inline bool Message::has_paymentinvitemessage() const {
  return _internal_has_paymentinvitemessage();
}
inline void Message::clear_paymentinvitemessage() {
  if (_impl_.paymentinvitemessage_ != nullptr) _impl_.paymentinvitemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline const ::proto::Message_PaymentInviteMessage& Message::_internal_paymentinvitemessage() const {
  const ::proto::Message_PaymentInviteMessage* p = _impl_.paymentinvitemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PaymentInviteMessage&>(
      ::proto::_Message_PaymentInviteMessage_default_instance_);
}
inline const ::proto::Message_PaymentInviteMessage& Message::paymentinvitemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.paymentInviteMessage)
  return _internal_paymentinvitemessage();
}
inline void Message::unsafe_arena_set_allocated_paymentinvitemessage(
    ::proto::Message_PaymentInviteMessage* paymentinvitemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinvitemessage_);
  }
  _impl_.paymentinvitemessage_ = paymentinvitemessage;
  if (paymentinvitemessage) {
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.paymentInviteMessage)
}
inline ::proto::Message_PaymentInviteMessage* Message::release_paymentinvitemessage() {
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_;
  _impl_.paymentinvitemessage_ = 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 ::proto::Message_PaymentInviteMessage* Message::unsafe_arena_release_paymentinvitemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.paymentInviteMessage)
  _impl_._has_bits_[1] &= ~0x00000008u;
  ::proto::Message_PaymentInviteMessage* temp = _impl_.paymentinvitemessage_;
  _impl_.paymentinvitemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_PaymentInviteMessage* Message::_internal_mutable_paymentinvitemessage() {
  _impl_._has_bits_[1] |= 0x00000008u;
  if (_impl_.paymentinvitemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PaymentInviteMessage>(GetArenaForAllocation());
    _impl_.paymentinvitemessage_ = p;
  }
  return _impl_.paymentinvitemessage_;
}
inline ::proto::Message_PaymentInviteMessage* Message::mutable_paymentinvitemessage() {
  ::proto::Message_PaymentInviteMessage* _msg = _internal_mutable_paymentinvitemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.paymentInviteMessage)
  return _msg;
}
inline void Message::set_allocated_paymentinvitemessage(::proto::Message_PaymentInviteMessage* paymentinvitemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.paymentinvitemessage_;
  }
  if (paymentinvitemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinvitemessage);
    if (message_arena != submessage_arena) {
      paymentinvitemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paymentinvitemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000008u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000008u;
  }
  _impl_.paymentinvitemessage_ = paymentinvitemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.paymentInviteMessage)
}

// optional .proto.Message.InteractiveMessage interactiveMessage = 45;
inline bool Message::_internal_has_interactivemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.interactivemessage_ != nullptr);
  return value;
}
inline bool Message::has_interactivemessage() const {
  return _internal_has_interactivemessage();
}
inline void Message::clear_interactivemessage() {
  if (_impl_.interactivemessage_ != nullptr) _impl_.interactivemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline const ::proto::Message_InteractiveMessage& Message::_internal_interactivemessage() const {
  const ::proto::Message_InteractiveMessage* p = _impl_.interactivemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveMessage&>(
      ::proto::_Message_InteractiveMessage_default_instance_);
}
inline const ::proto::Message_InteractiveMessage& Message::interactivemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.interactiveMessage)
  return _internal_interactivemessage();
}
inline void Message::unsafe_arena_set_allocated_interactivemessage(
    ::proto::Message_InteractiveMessage* interactivemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactivemessage_);
  }
  _impl_.interactivemessage_ = interactivemessage;
  if (interactivemessage) {
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveMessage)
}
inline ::proto::Message_InteractiveMessage* Message::release_interactivemessage() {
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_;
  _impl_.interactivemessage_ = 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 ::proto::Message_InteractiveMessage* Message::unsafe_arena_release_interactivemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.interactiveMessage)
  _impl_._has_bits_[1] &= ~0x00000010u;
  ::proto::Message_InteractiveMessage* temp = _impl_.interactivemessage_;
  _impl_.interactivemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveMessage* Message::_internal_mutable_interactivemessage() {
  _impl_._has_bits_[1] |= 0x00000010u;
  if (_impl_.interactivemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveMessage>(GetArenaForAllocation());
    _impl_.interactivemessage_ = p;
  }
  return _impl_.interactivemessage_;
}
inline ::proto::Message_InteractiveMessage* Message::mutable_interactivemessage() {
  ::proto::Message_InteractiveMessage* _msg = _internal_mutable_interactivemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.interactiveMessage)
  return _msg;
}
inline void Message::set_allocated_interactivemessage(::proto::Message_InteractiveMessage* interactivemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.interactivemessage_;
  }
  if (interactivemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactivemessage);
    if (message_arena != submessage_arena) {
      interactivemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interactivemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000010u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000010u;
  }
  _impl_.interactivemessage_ = interactivemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveMessage)
}

// optional .proto.Message.ReactionMessage reactionMessage = 46;
inline bool Message::_internal_has_reactionmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.reactionmessage_ != nullptr);
  return value;
}
inline bool Message::has_reactionmessage() const {
  return _internal_has_reactionmessage();
}
inline void Message::clear_reactionmessage() {
  if (_impl_.reactionmessage_ != nullptr) _impl_.reactionmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline const ::proto::Message_ReactionMessage& Message::_internal_reactionmessage() const {
  const ::proto::Message_ReactionMessage* p = _impl_.reactionmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_ReactionMessage&>(
      ::proto::_Message_ReactionMessage_default_instance_);
}
inline const ::proto::Message_ReactionMessage& Message::reactionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.reactionMessage)
  return _internal_reactionmessage();
}
inline void Message::unsafe_arena_set_allocated_reactionmessage(
    ::proto::Message_ReactionMessage* reactionmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.reactionmessage_);
  }
  _impl_.reactionmessage_ = reactionmessage;
  if (reactionmessage) {
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.reactionMessage)
}
inline ::proto::Message_ReactionMessage* Message::release_reactionmessage() {
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_;
  _impl_.reactionmessage_ = 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 ::proto::Message_ReactionMessage* Message::unsafe_arena_release_reactionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.reactionMessage)
  _impl_._has_bits_[1] &= ~0x00000020u;
  ::proto::Message_ReactionMessage* temp = _impl_.reactionmessage_;
  _impl_.reactionmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_ReactionMessage* Message::_internal_mutable_reactionmessage() {
  _impl_._has_bits_[1] |= 0x00000020u;
  if (_impl_.reactionmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_ReactionMessage>(GetArenaForAllocation());
    _impl_.reactionmessage_ = p;
  }
  return _impl_.reactionmessage_;
}
inline ::proto::Message_ReactionMessage* Message::mutable_reactionmessage() {
  ::proto::Message_ReactionMessage* _msg = _internal_mutable_reactionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.reactionMessage)
  return _msg;
}
inline void Message::set_allocated_reactionmessage(::proto::Message_ReactionMessage* reactionmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.reactionmessage_;
  }
  if (reactionmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(reactionmessage);
    if (message_arena != submessage_arena) {
      reactionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reactionmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000020u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000020u;
  }
  _impl_.reactionmessage_ = reactionmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.reactionMessage)
}

// optional .proto.Message.StickerSyncRMRMessage stickerSyncRmrMessage = 47;
inline bool Message::_internal_has_stickersyncrmrmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stickersyncrmrmessage_ != nullptr);
  return value;
}
inline bool Message::has_stickersyncrmrmessage() const {
  return _internal_has_stickersyncrmrmessage();
}
inline void Message::clear_stickersyncrmrmessage() {
  if (_impl_.stickersyncrmrmessage_ != nullptr) _impl_.stickersyncrmrmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline const ::proto::Message_StickerSyncRMRMessage& Message::_internal_stickersyncrmrmessage() const {
  const ::proto::Message_StickerSyncRMRMessage* p = _impl_.stickersyncrmrmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_StickerSyncRMRMessage&>(
      ::proto::_Message_StickerSyncRMRMessage_default_instance_);
}
inline const ::proto::Message_StickerSyncRMRMessage& Message::stickersyncrmrmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.stickerSyncRmrMessage)
  return _internal_stickersyncrmrmessage();
}
inline void Message::unsafe_arena_set_allocated_stickersyncrmrmessage(
    ::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickersyncrmrmessage_);
  }
  _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage;
  if (stickersyncrmrmessage) {
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.stickerSyncRmrMessage)
}
inline ::proto::Message_StickerSyncRMRMessage* Message::release_stickersyncrmrmessage() {
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_;
  _impl_.stickersyncrmrmessage_ = 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 ::proto::Message_StickerSyncRMRMessage* Message::unsafe_arena_release_stickersyncrmrmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.stickerSyncRmrMessage)
  _impl_._has_bits_[1] &= ~0x00000040u;
  ::proto::Message_StickerSyncRMRMessage* temp = _impl_.stickersyncrmrmessage_;
  _impl_.stickersyncrmrmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_StickerSyncRMRMessage* Message::_internal_mutable_stickersyncrmrmessage() {
  _impl_._has_bits_[1] |= 0x00000040u;
  if (_impl_.stickersyncrmrmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_StickerSyncRMRMessage>(GetArenaForAllocation());
    _impl_.stickersyncrmrmessage_ = p;
  }
  return _impl_.stickersyncrmrmessage_;
}
inline ::proto::Message_StickerSyncRMRMessage* Message::mutable_stickersyncrmrmessage() {
  ::proto::Message_StickerSyncRMRMessage* _msg = _internal_mutable_stickersyncrmrmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.stickerSyncRmrMessage)
  return _msg;
}
inline void Message::set_allocated_stickersyncrmrmessage(::proto::Message_StickerSyncRMRMessage* stickersyncrmrmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stickersyncrmrmessage_;
  }
  if (stickersyncrmrmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickersyncrmrmessage);
    if (message_arena != submessage_arena) {
      stickersyncrmrmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stickersyncrmrmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000040u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000040u;
  }
  _impl_.stickersyncrmrmessage_ = stickersyncrmrmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.stickerSyncRmrMessage)
}

// optional .proto.Message.InteractiveResponseMessage interactiveResponseMessage = 48;
inline bool Message::_internal_has_interactiveresponsemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.interactiveresponsemessage_ != nullptr);
  return value;
}
inline bool Message::has_interactiveresponsemessage() const {
  return _internal_has_interactiveresponsemessage();
}
inline void Message::clear_interactiveresponsemessage() {
  if (_impl_.interactiveresponsemessage_ != nullptr) _impl_.interactiveresponsemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline const ::proto::Message_InteractiveResponseMessage& Message::_internal_interactiveresponsemessage() const {
  const ::proto::Message_InteractiveResponseMessage* p = _impl_.interactiveresponsemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_InteractiveResponseMessage&>(
      ::proto::_Message_InteractiveResponseMessage_default_instance_);
}
inline const ::proto::Message_InteractiveResponseMessage& Message::interactiveresponsemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.interactiveResponseMessage)
  return _internal_interactiveresponsemessage();
}
inline void Message::unsafe_arena_set_allocated_interactiveresponsemessage(
    ::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.interactiveresponsemessage_);
  }
  _impl_.interactiveresponsemessage_ = interactiveresponsemessage;
  if (interactiveresponsemessage) {
    _impl_._has_bits_[1] |= 0x00000080u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.interactiveResponseMessage)
}
inline ::proto::Message_InteractiveResponseMessage* Message::release_interactiveresponsemessage() {
  _impl_._has_bits_[1] &= ~0x00000080u;
  ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_;
  _impl_.interactiveresponsemessage_ = 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 ::proto::Message_InteractiveResponseMessage* Message::unsafe_arena_release_interactiveresponsemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.interactiveResponseMessage)
  _impl_._has_bits_[1] &= ~0x00000080u;
  ::proto::Message_InteractiveResponseMessage* temp = _impl_.interactiveresponsemessage_;
  _impl_.interactiveresponsemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_InteractiveResponseMessage* Message::_internal_mutable_interactiveresponsemessage() {
  _impl_._has_bits_[1] |= 0x00000080u;
  if (_impl_.interactiveresponsemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_InteractiveResponseMessage>(GetArenaForAllocation());
    _impl_.interactiveresponsemessage_ = p;
  }
  return _impl_.interactiveresponsemessage_;
}
inline ::proto::Message_InteractiveResponseMessage* Message::mutable_interactiveresponsemessage() {
  ::proto::Message_InteractiveResponseMessage* _msg = _internal_mutable_interactiveresponsemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.interactiveResponseMessage)
  return _msg;
}
inline void Message::set_allocated_interactiveresponsemessage(::proto::Message_InteractiveResponseMessage* interactiveresponsemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.interactiveresponsemessage_;
  }
  if (interactiveresponsemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(interactiveresponsemessage);
    if (message_arena != submessage_arena) {
      interactiveresponsemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interactiveresponsemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000080u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000080u;
  }
  _impl_.interactiveresponsemessage_ = interactiveresponsemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.interactiveResponseMessage)
}

// optional .proto.Message.PollCreationMessage pollCreationMessage = 49;
inline bool Message::_internal_has_pollcreationmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pollcreationmessage_ != nullptr);
  return value;
}
inline bool Message::has_pollcreationmessage() const {
  return _internal_has_pollcreationmessage();
}
inline void Message::clear_pollcreationmessage() {
  if (_impl_.pollcreationmessage_ != nullptr) _impl_.pollcreationmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline const ::proto::Message_PollCreationMessage& Message::_internal_pollcreationmessage() const {
  const ::proto::Message_PollCreationMessage* p = _impl_.pollcreationmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollCreationMessage&>(
      ::proto::_Message_PollCreationMessage_default_instance_);
}
inline const ::proto::Message_PollCreationMessage& Message::pollcreationmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.pollCreationMessage)
  return _internal_pollcreationmessage();
}
inline void Message::unsafe_arena_set_allocated_pollcreationmessage(
    ::proto::Message_PollCreationMessage* pollcreationmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollcreationmessage_);
  }
  _impl_.pollcreationmessage_ = pollcreationmessage;
  if (pollcreationmessage) {
    _impl_._has_bits_[1] |= 0x00000100u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollCreationMessage)
}
inline ::proto::Message_PollCreationMessage* Message::release_pollcreationmessage() {
  _impl_._has_bits_[1] &= ~0x00000100u;
  ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_;
  _impl_.pollcreationmessage_ = 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 ::proto::Message_PollCreationMessage* Message::unsafe_arena_release_pollcreationmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.pollCreationMessage)
  _impl_._has_bits_[1] &= ~0x00000100u;
  ::proto::Message_PollCreationMessage* temp = _impl_.pollcreationmessage_;
  _impl_.pollcreationmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_PollCreationMessage* Message::_internal_mutable_pollcreationmessage() {
  _impl_._has_bits_[1] |= 0x00000100u;
  if (_impl_.pollcreationmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PollCreationMessage>(GetArenaForAllocation());
    _impl_.pollcreationmessage_ = p;
  }
  return _impl_.pollcreationmessage_;
}
inline ::proto::Message_PollCreationMessage* Message::mutable_pollcreationmessage() {
  ::proto::Message_PollCreationMessage* _msg = _internal_mutable_pollcreationmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.pollCreationMessage)
  return _msg;
}
inline void Message::set_allocated_pollcreationmessage(::proto::Message_PollCreationMessage* pollcreationmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pollcreationmessage_;
  }
  if (pollcreationmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollcreationmessage);
    if (message_arena != submessage_arena) {
      pollcreationmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pollcreationmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000100u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000100u;
  }
  _impl_.pollcreationmessage_ = pollcreationmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.pollCreationMessage)
}

// optional .proto.Message.PollUpdateMessage pollUpdateMessage = 50;
inline bool Message::_internal_has_pollupdatemessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pollupdatemessage_ != nullptr);
  return value;
}
inline bool Message::has_pollupdatemessage() const {
  return _internal_has_pollupdatemessage();
}
inline void Message::clear_pollupdatemessage() {
  if (_impl_.pollupdatemessage_ != nullptr) _impl_.pollupdatemessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline const ::proto::Message_PollUpdateMessage& Message::_internal_pollupdatemessage() const {
  const ::proto::Message_PollUpdateMessage* p = _impl_.pollupdatemessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollUpdateMessage&>(
      ::proto::_Message_PollUpdateMessage_default_instance_);
}
inline const ::proto::Message_PollUpdateMessage& Message::pollupdatemessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.pollUpdateMessage)
  return _internal_pollupdatemessage();
}
inline void Message::unsafe_arena_set_allocated_pollupdatemessage(
    ::proto::Message_PollUpdateMessage* pollupdatemessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessage_);
  }
  _impl_.pollupdatemessage_ = pollupdatemessage;
  if (pollupdatemessage) {
    _impl_._has_bits_[1] |= 0x00000200u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.pollUpdateMessage)
}
inline ::proto::Message_PollUpdateMessage* Message::release_pollupdatemessage() {
  _impl_._has_bits_[1] &= ~0x00000200u;
  ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_;
  _impl_.pollupdatemessage_ = 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 ::proto::Message_PollUpdateMessage* Message::unsafe_arena_release_pollupdatemessage() {
  // @@protoc_insertion_point(field_release:proto.Message.pollUpdateMessage)
  _impl_._has_bits_[1] &= ~0x00000200u;
  ::proto::Message_PollUpdateMessage* temp = _impl_.pollupdatemessage_;
  _impl_.pollupdatemessage_ = nullptr;
  return temp;
}
inline ::proto::Message_PollUpdateMessage* Message::_internal_mutable_pollupdatemessage() {
  _impl_._has_bits_[1] |= 0x00000200u;
  if (_impl_.pollupdatemessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PollUpdateMessage>(GetArenaForAllocation());
    _impl_.pollupdatemessage_ = p;
  }
  return _impl_.pollupdatemessage_;
}
inline ::proto::Message_PollUpdateMessage* Message::mutable_pollupdatemessage() {
  ::proto::Message_PollUpdateMessage* _msg = _internal_mutable_pollupdatemessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.pollUpdateMessage)
  return _msg;
}
inline void Message::set_allocated_pollupdatemessage(::proto::Message_PollUpdateMessage* pollupdatemessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pollupdatemessage_;
  }
  if (pollupdatemessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessage);
    if (message_arena != submessage_arena) {
      pollupdatemessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pollupdatemessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000200u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000200u;
  }
  _impl_.pollupdatemessage_ = pollupdatemessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.pollUpdateMessage)
}

// optional .proto.Message.KeepInChatMessage keepInChatMessage = 51;
inline bool Message::_internal_has_keepinchatmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keepinchatmessage_ != nullptr);
  return value;
}
inline bool Message::has_keepinchatmessage() const {
  return _internal_has_keepinchatmessage();
}
inline void Message::clear_keepinchatmessage() {
  if (_impl_.keepinchatmessage_ != nullptr) _impl_.keepinchatmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline const ::proto::Message_KeepInChatMessage& Message::_internal_keepinchatmessage() const {
  const ::proto::Message_KeepInChatMessage* p = _impl_.keepinchatmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_KeepInChatMessage&>(
      ::proto::_Message_KeepInChatMessage_default_instance_);
}
inline const ::proto::Message_KeepInChatMessage& Message::keepinchatmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.keepInChatMessage)
  return _internal_keepinchatmessage();
}
inline void Message::unsafe_arena_set_allocated_keepinchatmessage(
    ::proto::Message_KeepInChatMessage* keepinchatmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchatmessage_);
  }
  _impl_.keepinchatmessage_ = keepinchatmessage;
  if (keepinchatmessage) {
    _impl_._has_bits_[1] |= 0x00000400u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.keepInChatMessage)
}
inline ::proto::Message_KeepInChatMessage* Message::release_keepinchatmessage() {
  _impl_._has_bits_[1] &= ~0x00000400u;
  ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_;
  _impl_.keepinchatmessage_ = 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 ::proto::Message_KeepInChatMessage* Message::unsafe_arena_release_keepinchatmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.keepInChatMessage)
  _impl_._has_bits_[1] &= ~0x00000400u;
  ::proto::Message_KeepInChatMessage* temp = _impl_.keepinchatmessage_;
  _impl_.keepinchatmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_KeepInChatMessage* Message::_internal_mutable_keepinchatmessage() {
  _impl_._has_bits_[1] |= 0x00000400u;
  if (_impl_.keepinchatmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_KeepInChatMessage>(GetArenaForAllocation());
    _impl_.keepinchatmessage_ = p;
  }
  return _impl_.keepinchatmessage_;
}
inline ::proto::Message_KeepInChatMessage* Message::mutable_keepinchatmessage() {
  ::proto::Message_KeepInChatMessage* _msg = _internal_mutable_keepinchatmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.keepInChatMessage)
  return _msg;
}
inline void Message::set_allocated_keepinchatmessage(::proto::Message_KeepInChatMessage* keepinchatmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keepinchatmessage_;
  }
  if (keepinchatmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchatmessage);
    if (message_arena != submessage_arena) {
      keepinchatmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keepinchatmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000400u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000400u;
  }
  _impl_.keepinchatmessage_ = keepinchatmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.keepInChatMessage)
}

// optional .proto.Message.FutureProofMessage documentWithCaptionMessage = 53;
inline bool Message::_internal_has_documentwithcaptionmessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.documentwithcaptionmessage_ != nullptr);
  return value;
}
inline bool Message::has_documentwithcaptionmessage() const {
  return _internal_has_documentwithcaptionmessage();
}
inline void Message::clear_documentwithcaptionmessage() {
  if (_impl_.documentwithcaptionmessage_ != nullptr) _impl_.documentwithcaptionmessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline const ::proto::Message_FutureProofMessage& Message::_internal_documentwithcaptionmessage() const {
  const ::proto::Message_FutureProofMessage* p = _impl_.documentwithcaptionmessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
      ::proto::_Message_FutureProofMessage_default_instance_);
}
inline const ::proto::Message_FutureProofMessage& Message::documentwithcaptionmessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.documentWithCaptionMessage)
  return _internal_documentwithcaptionmessage();
}
inline void Message::unsafe_arena_set_allocated_documentwithcaptionmessage(
    ::proto::Message_FutureProofMessage* documentwithcaptionmessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.documentwithcaptionmessage_);
  }
  _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage;
  if (documentwithcaptionmessage) {
    _impl_._has_bits_[1] |= 0x00000800u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.documentWithCaptionMessage)
}
inline ::proto::Message_FutureProofMessage* Message::release_documentwithcaptionmessage() {
  _impl_._has_bits_[1] &= ~0x00000800u;
  ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_;
  _impl_.documentwithcaptionmessage_ = 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 ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_documentwithcaptionmessage() {
  // @@protoc_insertion_point(field_release:proto.Message.documentWithCaptionMessage)
  _impl_._has_bits_[1] &= ~0x00000800u;
  ::proto::Message_FutureProofMessage* temp = _impl_.documentwithcaptionmessage_;
  _impl_.documentwithcaptionmessage_ = nullptr;
  return temp;
}
inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_documentwithcaptionmessage() {
  _impl_._has_bits_[1] |= 0x00000800u;
  if (_impl_.documentwithcaptionmessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
    _impl_.documentwithcaptionmessage_ = p;
  }
  return _impl_.documentwithcaptionmessage_;
}
inline ::proto::Message_FutureProofMessage* Message::mutable_documentwithcaptionmessage() {
  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_documentwithcaptionmessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.documentWithCaptionMessage)
  return _msg;
}
inline void Message::set_allocated_documentwithcaptionmessage(::proto::Message_FutureProofMessage* documentwithcaptionmessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.documentwithcaptionmessage_;
  }
  if (documentwithcaptionmessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(documentwithcaptionmessage);
    if (message_arena != submessage_arena) {
      documentwithcaptionmessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, documentwithcaptionmessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00000800u;
  } else {
    _impl_._has_bits_[1] &= ~0x00000800u;
  }
  _impl_.documentwithcaptionmessage_ = documentwithcaptionmessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.documentWithCaptionMessage)
}

// optional .proto.Message.RequestPhoneNumberMessage requestPhoneNumberMessage = 54;
inline bool Message::_internal_has_requestphonenumbermessage() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestphonenumbermessage_ != nullptr);
  return value;
}
inline bool Message::has_requestphonenumbermessage() const {
  return _internal_has_requestphonenumbermessage();
}
inline void Message::clear_requestphonenumbermessage() {
  if (_impl_.requestphonenumbermessage_ != nullptr) _impl_.requestphonenumbermessage_->Clear();
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline const ::proto::Message_RequestPhoneNumberMessage& Message::_internal_requestphonenumbermessage() const {
  const ::proto::Message_RequestPhoneNumberMessage* p = _impl_.requestphonenumbermessage_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_RequestPhoneNumberMessage&>(
      ::proto::_Message_RequestPhoneNumberMessage_default_instance_);
}
inline const ::proto::Message_RequestPhoneNumberMessage& Message::requestphonenumbermessage() const {
  // @@protoc_insertion_point(field_get:proto.Message.requestPhoneNumberMessage)
  return _internal_requestphonenumbermessage();
}
inline void Message::unsafe_arena_set_allocated_requestphonenumbermessage(
    ::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestphonenumbermessage_);
  }
  _impl_.requestphonenumbermessage_ = requestphonenumbermessage;
  if (requestphonenumbermessage) {
    _impl_._has_bits_[1] |= 0x00001000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.requestPhoneNumberMessage)
}
inline ::proto::Message_RequestPhoneNumberMessage* Message::release_requestphonenumbermessage() {
  _impl_._has_bits_[1] &= ~0x00001000u;
  ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_;
  _impl_.requestphonenumbermessage_ = 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 ::proto::Message_RequestPhoneNumberMessage* Message::unsafe_arena_release_requestphonenumbermessage() {
  // @@protoc_insertion_point(field_release:proto.Message.requestPhoneNumberMessage)
  _impl_._has_bits_[1] &= ~0x00001000u;
  ::proto::Message_RequestPhoneNumberMessage* temp = _impl_.requestphonenumbermessage_;
  _impl_.requestphonenumbermessage_ = nullptr;
  return temp;
}
inline ::proto::Message_RequestPhoneNumberMessage* Message::_internal_mutable_requestphonenumbermessage() {
  _impl_._has_bits_[1] |= 0x00001000u;
  if (_impl_.requestphonenumbermessage_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_RequestPhoneNumberMessage>(GetArenaForAllocation());
    _impl_.requestphonenumbermessage_ = p;
  }
  return _impl_.requestphonenumbermessage_;
}
inline ::proto::Message_RequestPhoneNumberMessage* Message::mutable_requestphonenumbermessage() {
  ::proto::Message_RequestPhoneNumberMessage* _msg = _internal_mutable_requestphonenumbermessage();
  // @@protoc_insertion_point(field_mutable:proto.Message.requestPhoneNumberMessage)
  return _msg;
}
inline void Message::set_allocated_requestphonenumbermessage(::proto::Message_RequestPhoneNumberMessage* requestphonenumbermessage) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestphonenumbermessage_;
  }
  if (requestphonenumbermessage) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestphonenumbermessage);
    if (message_arena != submessage_arena) {
      requestphonenumbermessage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestphonenumbermessage, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00001000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00001000u;
  }
  _impl_.requestphonenumbermessage_ = requestphonenumbermessage;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.requestPhoneNumberMessage)
}

// optional .proto.Message.FutureProofMessage viewOnceMessageV2 = 55;
inline bool Message::_internal_has_viewoncemessagev2() const {
  bool value = (_impl_._has_bits_[1] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.viewoncemessagev2_ != nullptr);
  return value;
}
inline bool Message::has_viewoncemessagev2() const {
  return _internal_has_viewoncemessagev2();
}
inline void Message::clear_viewoncemessagev2() {
  if (_impl_.viewoncemessagev2_ != nullptr) _impl_.viewoncemessagev2_->Clear();
  _impl_._has_bits_[1] &= ~0x00002000u;
}
inline const ::proto::Message_FutureProofMessage& Message::_internal_viewoncemessagev2() const {
  const ::proto::Message_FutureProofMessage* p = _impl_.viewoncemessagev2_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_FutureProofMessage&>(
      ::proto::_Message_FutureProofMessage_default_instance_);
}
inline const ::proto::Message_FutureProofMessage& Message::viewoncemessagev2() const {
  // @@protoc_insertion_point(field_get:proto.Message.viewOnceMessageV2)
  return _internal_viewoncemessagev2();
}
inline void Message::unsafe_arena_set_allocated_viewoncemessagev2(
    ::proto::Message_FutureProofMessage* viewoncemessagev2) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.viewoncemessagev2_);
  }
  _impl_.viewoncemessagev2_ = viewoncemessagev2;
  if (viewoncemessagev2) {
    _impl_._has_bits_[1] |= 0x00002000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Message.viewOnceMessageV2)
}
inline ::proto::Message_FutureProofMessage* Message::release_viewoncemessagev2() {
  _impl_._has_bits_[1] &= ~0x00002000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_;
  _impl_.viewoncemessagev2_ = 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 ::proto::Message_FutureProofMessage* Message::unsafe_arena_release_viewoncemessagev2() {
  // @@protoc_insertion_point(field_release:proto.Message.viewOnceMessageV2)
  _impl_._has_bits_[1] &= ~0x00002000u;
  ::proto::Message_FutureProofMessage* temp = _impl_.viewoncemessagev2_;
  _impl_.viewoncemessagev2_ = nullptr;
  return temp;
}
inline ::proto::Message_FutureProofMessage* Message::_internal_mutable_viewoncemessagev2() {
  _impl_._has_bits_[1] |= 0x00002000u;
  if (_impl_.viewoncemessagev2_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_FutureProofMessage>(GetArenaForAllocation());
    _impl_.viewoncemessagev2_ = p;
  }
  return _impl_.viewoncemessagev2_;
}
inline ::proto::Message_FutureProofMessage* Message::mutable_viewoncemessagev2() {
  ::proto::Message_FutureProofMessage* _msg = _internal_mutable_viewoncemessagev2();
  // @@protoc_insertion_point(field_mutable:proto.Message.viewOnceMessageV2)
  return _msg;
}
inline void Message::set_allocated_viewoncemessagev2(::proto::Message_FutureProofMessage* viewoncemessagev2) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.viewoncemessagev2_;
  }
  if (viewoncemessagev2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(viewoncemessagev2);
    if (message_arena != submessage_arena) {
      viewoncemessagev2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, viewoncemessagev2, submessage_arena);
    }
    _impl_._has_bits_[1] |= 0x00002000u;
  } else {
    _impl_._has_bits_[1] &= ~0x00002000u;
  }
  _impl_.viewoncemessagev2_ = viewoncemessagev2;
  // @@protoc_insertion_point(field_set_allocated:proto.Message.viewOnceMessageV2)
}

// -------------------------------------------------------------------

// MessageContextInfo

// optional .proto.DeviceListMetadata deviceListMetadata = 1;
inline bool MessageContextInfo::_internal_has_devicelistmetadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.devicelistmetadata_ != nullptr);
  return value;
}
inline bool MessageContextInfo::has_devicelistmetadata() const {
  return _internal_has_devicelistmetadata();
}
inline void MessageContextInfo::clear_devicelistmetadata() {
  if (_impl_.devicelistmetadata_ != nullptr) _impl_.devicelistmetadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::DeviceListMetadata& MessageContextInfo::_internal_devicelistmetadata() const {
  const ::proto::DeviceListMetadata* p = _impl_.devicelistmetadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::DeviceListMetadata&>(
      ::proto::_DeviceListMetadata_default_instance_);
}
inline const ::proto::DeviceListMetadata& MessageContextInfo::devicelistmetadata() const {
  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadata)
  return _internal_devicelistmetadata();
}
inline void MessageContextInfo::unsafe_arena_set_allocated_devicelistmetadata(
    ::proto::DeviceListMetadata* devicelistmetadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.devicelistmetadata_);
  }
  _impl_.devicelistmetadata_ = devicelistmetadata;
  if (devicelistmetadata) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MessageContextInfo.deviceListMetadata)
}
inline ::proto::DeviceListMetadata* MessageContextInfo::release_devicelistmetadata() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_;
  _impl_.devicelistmetadata_ = 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 ::proto::DeviceListMetadata* MessageContextInfo::unsafe_arena_release_devicelistmetadata() {
  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.deviceListMetadata)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::DeviceListMetadata* temp = _impl_.devicelistmetadata_;
  _impl_.devicelistmetadata_ = nullptr;
  return temp;
}
inline ::proto::DeviceListMetadata* MessageContextInfo::_internal_mutable_devicelistmetadata() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.devicelistmetadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::DeviceListMetadata>(GetArenaForAllocation());
    _impl_.devicelistmetadata_ = p;
  }
  return _impl_.devicelistmetadata_;
}
inline ::proto::DeviceListMetadata* MessageContextInfo::mutable_devicelistmetadata() {
  ::proto::DeviceListMetadata* _msg = _internal_mutable_devicelistmetadata();
  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.deviceListMetadata)
  return _msg;
}
inline void MessageContextInfo::set_allocated_devicelistmetadata(::proto::DeviceListMetadata* devicelistmetadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.devicelistmetadata_;
  }
  if (devicelistmetadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(devicelistmetadata);
    if (message_arena != submessage_arena) {
      devicelistmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, devicelistmetadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.devicelistmetadata_ = devicelistmetadata;
  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.deviceListMetadata)
}

// optional int32 deviceListMetadataVersion = 2;
inline bool MessageContextInfo::_internal_has_devicelistmetadataversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MessageContextInfo::has_devicelistmetadataversion() const {
  return _internal_has_devicelistmetadataversion();
}
inline void MessageContextInfo::clear_devicelistmetadataversion() {
  _impl_.devicelistmetadataversion_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t MessageContextInfo::_internal_devicelistmetadataversion() const {
  return _impl_.devicelistmetadataversion_;
}
inline int32_t MessageContextInfo::devicelistmetadataversion() const {
  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.deviceListMetadataVersion)
  return _internal_devicelistmetadataversion();
}
inline void MessageContextInfo::_internal_set_devicelistmetadataversion(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.devicelistmetadataversion_ = value;
}
inline void MessageContextInfo::set_devicelistmetadataversion(int32_t value) {
  _internal_set_devicelistmetadataversion(value);
  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.deviceListMetadataVersion)
}

// optional bytes messageSecret = 3;
inline bool MessageContextInfo::_internal_has_messagesecret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MessageContextInfo::has_messagesecret() const {
  return _internal_has_messagesecret();
}
inline void MessageContextInfo::clear_messagesecret() {
  _impl_.messagesecret_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MessageContextInfo::messagesecret() const {
  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.messageSecret)
  return _internal_messagesecret();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageContextInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.messageSecret)
}
inline std::string* MessageContextInfo::mutable_messagesecret() {
  std::string* _s = _internal_mutable_messagesecret();
  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.messageSecret)
  return _s;
}
inline const std::string& MessageContextInfo::_internal_messagesecret() const {
  return _impl_.messagesecret_.Get();
}
inline void MessageContextInfo::_internal_set_messagesecret(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageContextInfo::_internal_mutable_messagesecret() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageContextInfo::release_messagesecret() {
  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.messageSecret)
  if (!_internal_has_messagesecret()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.messagesecret_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageContextInfo::set_allocated_messagesecret(std::string* messagesecret) {
  if (messagesecret != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.messageSecret)
}

// optional bytes paddingBytes = 4;
inline bool MessageContextInfo::_internal_has_paddingbytes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MessageContextInfo::has_paddingbytes() const {
  return _internal_has_paddingbytes();
}
inline void MessageContextInfo::clear_paddingbytes() {
  _impl_.paddingbytes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MessageContextInfo::paddingbytes() const {
  // @@protoc_insertion_point(field_get:proto.MessageContextInfo.paddingBytes)
  return _internal_paddingbytes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageContextInfo::set_paddingbytes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.paddingbytes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MessageContextInfo.paddingBytes)
}
inline std::string* MessageContextInfo::mutable_paddingbytes() {
  std::string* _s = _internal_mutable_paddingbytes();
  // @@protoc_insertion_point(field_mutable:proto.MessageContextInfo.paddingBytes)
  return _s;
}
inline const std::string& MessageContextInfo::_internal_paddingbytes() const {
  return _impl_.paddingbytes_.Get();
}
inline void MessageContextInfo::_internal_set_paddingbytes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.paddingbytes_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageContextInfo::_internal_mutable_paddingbytes() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.paddingbytes_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageContextInfo::release_paddingbytes() {
  // @@protoc_insertion_point(field_release:proto.MessageContextInfo.paddingBytes)
  if (!_internal_has_paddingbytes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.paddingbytes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paddingbytes_.IsDefault()) {
    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageContextInfo::set_allocated_paddingbytes(std::string* paddingbytes) {
  if (paddingbytes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.paddingbytes_.SetAllocated(paddingbytes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paddingbytes_.IsDefault()) {
    _impl_.paddingbytes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MessageContextInfo.paddingBytes)
}

// -------------------------------------------------------------------

// MessageKey

// optional string remoteJid = 1;
inline bool MessageKey::_internal_has_remotejid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MessageKey::has_remotejid() const {
  return _internal_has_remotejid();
}
inline void MessageKey::clear_remotejid() {
  _impl_.remotejid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MessageKey::remotejid() const {
  // @@protoc_insertion_point(field_get:proto.MessageKey.remoteJid)
  return _internal_remotejid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageKey::set_remotejid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.remotejid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MessageKey.remoteJid)
}
inline std::string* MessageKey::mutable_remotejid() {
  std::string* _s = _internal_mutable_remotejid();
  // @@protoc_insertion_point(field_mutable:proto.MessageKey.remoteJid)
  return _s;
}
inline const std::string& MessageKey::_internal_remotejid() const {
  return _impl_.remotejid_.Get();
}
inline void MessageKey::_internal_set_remotejid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.remotejid_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageKey::_internal_mutable_remotejid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.remotejid_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageKey::release_remotejid() {
  // @@protoc_insertion_point(field_release:proto.MessageKey.remoteJid)
  if (!_internal_has_remotejid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.remotejid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remotejid_.IsDefault()) {
    _impl_.remotejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageKey::set_allocated_remotejid(std::string* remotejid) {
  if (remotejid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.remotejid_.SetAllocated(remotejid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remotejid_.IsDefault()) {
    _impl_.remotejid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.remoteJid)
}

// optional bool fromMe = 2;
inline bool MessageKey::_internal_has_fromme() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MessageKey::has_fromme() const {
  return _internal_has_fromme();
}
inline void MessageKey::clear_fromme() {
  _impl_.fromme_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool MessageKey::_internal_fromme() const {
  return _impl_.fromme_;
}
inline bool MessageKey::fromme() const {
  // @@protoc_insertion_point(field_get:proto.MessageKey.fromMe)
  return _internal_fromme();
}
inline void MessageKey::_internal_set_fromme(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.fromme_ = value;
}
inline void MessageKey::set_fromme(bool value) {
  _internal_set_fromme(value);
  // @@protoc_insertion_point(field_set:proto.MessageKey.fromMe)
}

// optional string id = 3;
inline bool MessageKey::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MessageKey::has_id() const {
  return _internal_has_id();
}
inline void MessageKey::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MessageKey::id() const {
  // @@protoc_insertion_point(field_get:proto.MessageKey.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageKey::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MessageKey.id)
}
inline std::string* MessageKey::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.MessageKey.id)
  return _s;
}
inline const std::string& MessageKey::_internal_id() const {
  return _impl_.id_.Get();
}
inline void MessageKey::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageKey::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageKey::release_id() {
  // @@protoc_insertion_point(field_release:proto.MessageKey.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageKey::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.id)
}

// optional string participant = 4;
inline bool MessageKey::_internal_has_participant() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MessageKey::has_participant() const {
  return _internal_has_participant();
}
inline void MessageKey::clear_participant() {
  _impl_.participant_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& MessageKey::participant() const {
  // @@protoc_insertion_point(field_get:proto.MessageKey.participant)
  return _internal_participant();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MessageKey::set_participant(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MessageKey.participant)
}
inline std::string* MessageKey::mutable_participant() {
  std::string* _s = _internal_mutable_participant();
  // @@protoc_insertion_point(field_mutable:proto.MessageKey.participant)
  return _s;
}
inline const std::string& MessageKey::_internal_participant() const {
  return _impl_.participant_.Get();
}
inline void MessageKey::_internal_set_participant(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.participant_.Set(value, GetArenaForAllocation());
}
inline std::string* MessageKey::_internal_mutable_participant() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.participant_.Mutable(GetArenaForAllocation());
}
inline std::string* MessageKey::release_participant() {
  // @@protoc_insertion_point(field_release:proto.MessageKey.participant)
  if (!_internal_has_participant()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.participant_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MessageKey::set_allocated_participant(std::string* participant) {
  if (participant != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MessageKey.participant)
}

// -------------------------------------------------------------------

// Money

// optional int64 value = 1;
inline bool Money::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Money::has_value() const {
  return _internal_has_value();
}
inline void Money::clear_value() {
  _impl_.value_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t Money::_internal_value() const {
  return _impl_.value_;
}
inline int64_t Money::value() const {
  // @@protoc_insertion_point(field_get:proto.Money.value)
  return _internal_value();
}
inline void Money::_internal_set_value(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.value_ = value;
}
inline void Money::set_value(int64_t value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:proto.Money.value)
}

// optional uint32 offset = 2;
inline bool Money::_internal_has_offset() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Money::has_offset() const {
  return _internal_has_offset();
}
inline void Money::clear_offset() {
  _impl_.offset_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t Money::_internal_offset() const {
  return _impl_.offset_;
}
inline uint32_t Money::offset() const {
  // @@protoc_insertion_point(field_get:proto.Money.offset)
  return _internal_offset();
}
inline void Money::_internal_set_offset(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.offset_ = value;
}
inline void Money::set_offset(uint32_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:proto.Money.offset)
}

// optional string currencyCode = 3;
inline bool Money::_internal_has_currencycode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Money::has_currencycode() const {
  return _internal_has_currencycode();
}
inline void Money::clear_currencycode() {
  _impl_.currencycode_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Money::currencycode() const {
  // @@protoc_insertion_point(field_get:proto.Money.currencyCode)
  return _internal_currencycode();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Money::set_currencycode(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.currencycode_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Money.currencyCode)
}
inline std::string* Money::mutable_currencycode() {
  std::string* _s = _internal_mutable_currencycode();
  // @@protoc_insertion_point(field_mutable:proto.Money.currencyCode)
  return _s;
}
inline const std::string& Money::_internal_currencycode() const {
  return _impl_.currencycode_.Get();
}
inline void Money::_internal_set_currencycode(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.currencycode_.Set(value, GetArenaForAllocation());
}
inline std::string* Money::_internal_mutable_currencycode() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.currencycode_.Mutable(GetArenaForAllocation());
}
inline std::string* Money::release_currencycode() {
  // @@protoc_insertion_point(field_release:proto.Money.currencyCode)
  if (!_internal_has_currencycode()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.currencycode_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Money::set_allocated_currencycode(std::string* currencycode) {
  if (currencycode != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.currencycode_.SetAllocated(currencycode, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currencycode_.IsDefault()) {
    _impl_.currencycode_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Money.currencyCode)
}

// -------------------------------------------------------------------

// MsgOpaqueData_PollOption

// optional string name = 1;
inline bool MsgOpaqueData_PollOption::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MsgOpaqueData_PollOption::has_name() const {
  return _internal_has_name();
}
inline void MsgOpaqueData_PollOption::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MsgOpaqueData_PollOption::name() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.PollOption.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData_PollOption::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.PollOption.name)
}
inline std::string* MsgOpaqueData_PollOption::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.PollOption.name)
  return _s;
}
inline const std::string& MsgOpaqueData_PollOption::_internal_name() const {
  return _impl_.name_.Get();
}
inline void MsgOpaqueData_PollOption::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData_PollOption::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData_PollOption::release_name() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.PollOption.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 MsgOpaqueData_PollOption::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.MsgOpaqueData.PollOption.name)
}

// -------------------------------------------------------------------

// MsgOpaqueData

// optional string body = 1;
inline bool MsgOpaqueData::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_body() const {
  return _internal_has_body();
}
inline void MsgOpaqueData::clear_body() {
  _impl_.body_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MsgOpaqueData::body() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::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:proto.MsgOpaqueData.body)
}
inline std::string* MsgOpaqueData::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.body)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_body() const {
  return _impl_.body_.Get();
}
inline void MsgOpaqueData::_internal_set_body(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.body_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.body_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_body() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.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 MsgOpaqueData::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:proto.MsgOpaqueData.body)
}

// optional string caption = 3;
inline bool MsgOpaqueData::_internal_has_caption() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_caption() const {
  return _internal_has_caption();
}
inline void MsgOpaqueData::clear_caption() {
  _impl_.caption_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MsgOpaqueData::caption() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.caption)
  return _internal_caption();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_caption(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.caption_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.caption)
}
inline std::string* MsgOpaqueData::mutable_caption() {
  std::string* _s = _internal_mutable_caption();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.caption)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_caption() const {
  return _impl_.caption_.Get();
}
inline void MsgOpaqueData::_internal_set_caption(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.caption_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_caption() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.caption_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_caption() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.caption)
  if (!_internal_has_caption()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  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 MsgOpaqueData::set_allocated_caption(std::string* caption) {
  if (caption != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _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:proto.MsgOpaqueData.caption)
}

// optional double lng = 5;
inline bool MsgOpaqueData::_internal_has_lng() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_lng() const {
  return _internal_has_lng();
}
inline void MsgOpaqueData::clear_lng() {
  _impl_.lng_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline double MsgOpaqueData::_internal_lng() const {
  return _impl_.lng_;
}
inline double MsgOpaqueData::lng() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lng)
  return _internal_lng();
}
inline void MsgOpaqueData::_internal_set_lng(double value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.lng_ = value;
}
inline void MsgOpaqueData::set_lng(double value) {
  _internal_set_lng(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lng)
}

// optional bool isLive = 6;
inline bool MsgOpaqueData::_internal_has_islive() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_islive() const {
  return _internal_has_islive();
}
inline void MsgOpaqueData::clear_islive() {
  _impl_.islive_ = false;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline bool MsgOpaqueData::_internal_islive() const {
  return _impl_.islive_;
}
inline bool MsgOpaqueData::islive() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.isLive)
  return _internal_islive();
}
inline void MsgOpaqueData::_internal_set_islive(bool value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.islive_ = value;
}
inline void MsgOpaqueData::set_islive(bool value) {
  _internal_set_islive(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.isLive)
}

// optional double lat = 7;
inline bool MsgOpaqueData::_internal_has_lat() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_lat() const {
  return _internal_has_lat();
}
inline void MsgOpaqueData::clear_lat() {
  _impl_.lat_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline double MsgOpaqueData::_internal_lat() const {
  return _impl_.lat_;
}
inline double MsgOpaqueData::lat() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.lat)
  return _internal_lat();
}
inline void MsgOpaqueData::_internal_set_lat(double value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.lat_ = value;
}
inline void MsgOpaqueData::set_lat(double value) {
  _internal_set_lat(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.lat)
}

// optional int32 paymentAmount1000 = 8;
inline bool MsgOpaqueData::_internal_has_paymentamount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_paymentamount1000() const {
  return _internal_has_paymentamount1000();
}
inline void MsgOpaqueData::clear_paymentamount1000() {
  _impl_.paymentamount1000_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline int32_t MsgOpaqueData::_internal_paymentamount1000() const {
  return _impl_.paymentamount1000_;
}
inline int32_t MsgOpaqueData::paymentamount1000() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentAmount1000)
  return _internal_paymentamount1000();
}
inline void MsgOpaqueData::_internal_set_paymentamount1000(int32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.paymentamount1000_ = value;
}
inline void MsgOpaqueData::set_paymentamount1000(int32_t value) {
  _internal_set_paymentamount1000(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentAmount1000)
}

// optional string paymentNoteMsgBody = 9;
inline bool MsgOpaqueData::_internal_has_paymentnotemsgbody() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_paymentnotemsgbody() const {
  return _internal_has_paymentnotemsgbody();
}
inline void MsgOpaqueData::clear_paymentnotemsgbody() {
  _impl_.paymentnotemsgbody_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& MsgOpaqueData::paymentnotemsgbody() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.paymentNoteMsgBody)
  return _internal_paymentnotemsgbody();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_paymentnotemsgbody(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.paymentnotemsgbody_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.paymentNoteMsgBody)
}
inline std::string* MsgOpaqueData::mutable_paymentnotemsgbody() {
  std::string* _s = _internal_mutable_paymentnotemsgbody();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.paymentNoteMsgBody)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_paymentnotemsgbody() const {
  return _impl_.paymentnotemsgbody_.Get();
}
inline void MsgOpaqueData::_internal_set_paymentnotemsgbody(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.paymentnotemsgbody_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_paymentnotemsgbody() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.paymentnotemsgbody_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_paymentnotemsgbody() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.paymentNoteMsgBody)
  if (!_internal_has_paymentnotemsgbody()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.paymentnotemsgbody_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paymentnotemsgbody_.IsDefault()) {
    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_paymentnotemsgbody(std::string* paymentnotemsgbody) {
  if (paymentnotemsgbody != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.paymentnotemsgbody_.SetAllocated(paymentnotemsgbody, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.paymentnotemsgbody_.IsDefault()) {
    _impl_.paymentnotemsgbody_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.paymentNoteMsgBody)
}

// optional string canonicalUrl = 10;
inline bool MsgOpaqueData::_internal_has_canonicalurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_canonicalurl() const {
  return _internal_has_canonicalurl();
}
inline void MsgOpaqueData::clear_canonicalurl() {
  _impl_.canonicalurl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& MsgOpaqueData::canonicalurl() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.canonicalUrl)
  return _internal_canonicalurl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_canonicalurl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.canonicalurl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.canonicalUrl)
}
inline std::string* MsgOpaqueData::mutable_canonicalurl() {
  std::string* _s = _internal_mutable_canonicalurl();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.canonicalUrl)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_canonicalurl() const {
  return _impl_.canonicalurl_.Get();
}
inline void MsgOpaqueData::_internal_set_canonicalurl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.canonicalurl_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_canonicalurl() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.canonicalurl_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_canonicalurl() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.canonicalUrl)
  if (!_internal_has_canonicalurl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.canonicalurl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.canonicalurl_.IsDefault()) {
    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_canonicalurl(std::string* canonicalurl) {
  if (canonicalurl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.canonicalurl_.SetAllocated(canonicalurl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.canonicalurl_.IsDefault()) {
    _impl_.canonicalurl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.canonicalUrl)
}

// optional string matchedText = 11;
inline bool MsgOpaqueData::_internal_has_matchedtext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_matchedtext() const {
  return _internal_has_matchedtext();
}
inline void MsgOpaqueData::clear_matchedtext() {
  _impl_.matchedtext_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& MsgOpaqueData::matchedtext() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.matchedText)
  return _internal_matchedtext();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_matchedtext(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.matchedtext_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.matchedText)
}
inline std::string* MsgOpaqueData::mutable_matchedtext() {
  std::string* _s = _internal_mutable_matchedtext();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.matchedText)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_matchedtext() const {
  return _impl_.matchedtext_.Get();
}
inline void MsgOpaqueData::_internal_set_matchedtext(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.matchedtext_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_matchedtext() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.matchedtext_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_matchedtext() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.matchedText)
  if (!_internal_has_matchedtext()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.matchedtext_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.matchedtext_.IsDefault()) {
    _impl_.matchedtext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_matchedtext(std::string* matchedtext) {
  if (matchedtext != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.matchedtext_.SetAllocated(matchedtext, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.matchedtext_.IsDefault()) {
    _impl_.matchedtext_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.matchedText)
}

// optional string title = 12;
inline bool MsgOpaqueData::_internal_has_title() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_title() const {
  return _internal_has_title();
}
inline void MsgOpaqueData::clear_title() {
  _impl_.title_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& MsgOpaqueData::title() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.title)
  return _internal_title();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_title(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.title_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.title)
}
inline std::string* MsgOpaqueData::mutable_title() {
  std::string* _s = _internal_mutable_title();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.title)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_title() const {
  return _impl_.title_.Get();
}
inline void MsgOpaqueData::_internal_set_title(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.title_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_title() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.title_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_title() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.title)
  if (!_internal_has_title()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  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 MsgOpaqueData::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _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:proto.MsgOpaqueData.title)
}

// optional string description = 13;
inline bool MsgOpaqueData::_internal_has_description() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_description() const {
  return _internal_has_description();
}
inline void MsgOpaqueData::clear_description() {
  _impl_.description_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& MsgOpaqueData::description() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.description)
  return _internal_description();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_description(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.description_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.description)
}
inline std::string* MsgOpaqueData::mutable_description() {
  std::string* _s = _internal_mutable_description();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.description)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_description() const {
  return _impl_.description_.Get();
}
inline void MsgOpaqueData::_internal_set_description(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.description_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_description() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.description_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_description() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.description_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.description_.SetAllocated(description, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.description_.IsDefault()) {
    _impl_.description_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.description)
}

// optional bytes futureproofBuffer = 14;
inline bool MsgOpaqueData::_internal_has_futureproofbuffer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_futureproofbuffer() const {
  return _internal_has_futureproofbuffer();
}
inline void MsgOpaqueData::clear_futureproofbuffer() {
  _impl_.futureproofbuffer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& MsgOpaqueData::futureproofbuffer() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.futureproofBuffer)
  return _internal_futureproofbuffer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_futureproofbuffer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.futureproofbuffer_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.futureproofBuffer)
}
inline std::string* MsgOpaqueData::mutable_futureproofbuffer() {
  std::string* _s = _internal_mutable_futureproofbuffer();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.futureproofBuffer)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_futureproofbuffer() const {
  return _impl_.futureproofbuffer_.Get();
}
inline void MsgOpaqueData::_internal_set_futureproofbuffer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.futureproofbuffer_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_futureproofbuffer() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.futureproofbuffer_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_futureproofbuffer() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.futureproofBuffer)
  if (!_internal_has_futureproofbuffer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.futureproofbuffer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.futureproofbuffer_.IsDefault()) {
    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_futureproofbuffer(std::string* futureproofbuffer) {
  if (futureproofbuffer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.futureproofbuffer_.SetAllocated(futureproofbuffer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.futureproofbuffer_.IsDefault()) {
    _impl_.futureproofbuffer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.futureproofBuffer)
}

// optional string clientUrl = 15;
inline bool MsgOpaqueData::_internal_has_clienturl() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_clienturl() const {
  return _internal_has_clienturl();
}
inline void MsgOpaqueData::clear_clienturl() {
  _impl_.clienturl_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const std::string& MsgOpaqueData::clienturl() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.clientUrl)
  return _internal_clienturl();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_clienturl(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000100u;
 _impl_.clienturl_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.clientUrl)
}
inline std::string* MsgOpaqueData::mutable_clienturl() {
  std::string* _s = _internal_mutable_clienturl();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.clientUrl)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_clienturl() const {
  return _impl_.clienturl_.Get();
}
inline void MsgOpaqueData::_internal_set_clienturl(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.clienturl_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_clienturl() {
  _impl_._has_bits_[0] |= 0x00000100u;
  return _impl_.clienturl_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_clienturl() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.clientUrl)
  if (!_internal_has_clienturl()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000100u;
  auto* p = _impl_.clienturl_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.clienturl_.IsDefault()) {
    _impl_.clienturl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_clienturl(std::string* clienturl) {
  if (clienturl != nullptr) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.clienturl_.SetAllocated(clienturl, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.clienturl_.IsDefault()) {
    _impl_.clienturl_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.clientUrl)
}

// optional string loc = 16;
inline bool MsgOpaqueData::_internal_has_loc() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_loc() const {
  return _internal_has_loc();
}
inline void MsgOpaqueData::clear_loc() {
  _impl_.loc_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const std::string& MsgOpaqueData::loc() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.loc)
  return _internal_loc();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_loc(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000200u;
 _impl_.loc_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.loc)
}
inline std::string* MsgOpaqueData::mutable_loc() {
  std::string* _s = _internal_mutable_loc();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.loc)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_loc() const {
  return _impl_.loc_.Get();
}
inline void MsgOpaqueData::_internal_set_loc(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.loc_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_loc() {
  _impl_._has_bits_[0] |= 0x00000200u;
  return _impl_.loc_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_loc() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.loc)
  if (!_internal_has_loc()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000200u;
  auto* p = _impl_.loc_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.loc_.IsDefault()) {
    _impl_.loc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_loc(std::string* loc) {
  if (loc != nullptr) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.loc_.SetAllocated(loc, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.loc_.IsDefault()) {
    _impl_.loc_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.loc)
}

// optional string pollName = 17;
inline bool MsgOpaqueData::_internal_has_pollname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_pollname() const {
  return _internal_has_pollname();
}
inline void MsgOpaqueData::clear_pollname() {
  _impl_.pollname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const std::string& MsgOpaqueData::pollname() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollName)
  return _internal_pollname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_pollname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000400u;
 _impl_.pollname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollName)
}
inline std::string* MsgOpaqueData::mutable_pollname() {
  std::string* _s = _internal_mutable_pollname();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollName)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_pollname() const {
  return _impl_.pollname_.Get();
}
inline void MsgOpaqueData::_internal_set_pollname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.pollname_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_pollname() {
  _impl_._has_bits_[0] |= 0x00000400u;
  return _impl_.pollname_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_pollname() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollName)
  if (!_internal_has_pollname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000400u;
  auto* p = _impl_.pollname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pollname_.IsDefault()) {
    _impl_.pollname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_pollname(std::string* pollname) {
  if (pollname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.pollname_.SetAllocated(pollname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pollname_.IsDefault()) {
    _impl_.pollname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollName)
}

// repeated .proto.MsgOpaqueData.PollOption pollOptions = 18;
inline int MsgOpaqueData::_internal_polloptions_size() const {
  return _impl_.polloptions_.size();
}
inline int MsgOpaqueData::polloptions_size() const {
  return _internal_polloptions_size();
}
inline void MsgOpaqueData::clear_polloptions() {
  _impl_.polloptions_.Clear();
}
inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::mutable_polloptions(int index) {
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollOptions)
  return _impl_.polloptions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >*
MsgOpaqueData::mutable_polloptions() {
  // @@protoc_insertion_point(field_mutable_list:proto.MsgOpaqueData.pollOptions)
  return &_impl_.polloptions_;
}
inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::_internal_polloptions(int index) const {
  return _impl_.polloptions_.Get(index);
}
inline const ::proto::MsgOpaqueData_PollOption& MsgOpaqueData::polloptions(int index) const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollOptions)
  return _internal_polloptions(index);
}
inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::_internal_add_polloptions() {
  return _impl_.polloptions_.Add();
}
inline ::proto::MsgOpaqueData_PollOption* MsgOpaqueData::add_polloptions() {
  ::proto::MsgOpaqueData_PollOption* _add = _internal_add_polloptions();
  // @@protoc_insertion_point(field_add:proto.MsgOpaqueData.pollOptions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::MsgOpaqueData_PollOption >&
MsgOpaqueData::polloptions() const {
  // @@protoc_insertion_point(field_list:proto.MsgOpaqueData.pollOptions)
  return _impl_.polloptions_;
}

// optional uint32 pollSelectableOptionsCount = 20;
inline bool MsgOpaqueData::_internal_has_pollselectableoptionscount() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_pollselectableoptionscount() const {
  return _internal_has_pollselectableoptionscount();
}
inline void MsgOpaqueData::clear_pollselectableoptionscount() {
  _impl_.pollselectableoptionscount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t MsgOpaqueData::_internal_pollselectableoptionscount() const {
  return _impl_.pollselectableoptionscount_;
}
inline uint32_t MsgOpaqueData::pollselectableoptionscount() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollSelectableOptionsCount)
  return _internal_pollselectableoptionscount();
}
inline void MsgOpaqueData::_internal_set_pollselectableoptionscount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.pollselectableoptionscount_ = value;
}
inline void MsgOpaqueData::set_pollselectableoptionscount(uint32_t value) {
  _internal_set_pollselectableoptionscount(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollSelectableOptionsCount)
}

// optional bytes messageSecret = 21;
inline bool MsgOpaqueData::_internal_has_messagesecret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_messagesecret() const {
  return _internal_has_messagesecret();
}
inline void MsgOpaqueData::clear_messagesecret() {
  _impl_.messagesecret_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const std::string& MsgOpaqueData::messagesecret() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.messageSecret)
  return _internal_messagesecret();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_messagesecret(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000800u;
 _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.messageSecret)
}
inline std::string* MsgOpaqueData::mutable_messagesecret() {
  std::string* _s = _internal_mutable_messagesecret();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.messageSecret)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_messagesecret() const {
  return _impl_.messagesecret_.Get();
}
inline void MsgOpaqueData::_internal_set_messagesecret(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_messagesecret() {
  _impl_._has_bits_[0] |= 0x00000800u;
  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_messagesecret() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.messageSecret)
  if (!_internal_has_messagesecret()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000800u;
  auto* p = _impl_.messagesecret_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_messagesecret(std::string* messagesecret) {
  if (messagesecret != nullptr) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.messageSecret)
}

// optional int64 senderTimestampMs = 22;
inline bool MsgOpaqueData::_internal_has_sendertimestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_sendertimestampms() const {
  return _internal_has_sendertimestampms();
}
inline void MsgOpaqueData::clear_sendertimestampms() {
  _impl_.sendertimestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline int64_t MsgOpaqueData::_internal_sendertimestampms() const {
  return _impl_.sendertimestampms_;
}
inline int64_t MsgOpaqueData::sendertimestampms() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.senderTimestampMs)
  return _internal_sendertimestampms();
}
inline void MsgOpaqueData::_internal_set_sendertimestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.sendertimestampms_ = value;
}
inline void MsgOpaqueData::set_sendertimestampms(int64_t value) {
  _internal_set_sendertimestampms(value);
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.senderTimestampMs)
}

// optional string pollUpdateParentKey = 23;
inline bool MsgOpaqueData::_internal_has_pollupdateparentkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool MsgOpaqueData::has_pollupdateparentkey() const {
  return _internal_has_pollupdateparentkey();
}
inline void MsgOpaqueData::clear_pollupdateparentkey() {
  _impl_.pollupdateparentkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const std::string& MsgOpaqueData::pollupdateparentkey() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.pollUpdateParentKey)
  return _internal_pollupdateparentkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MsgOpaqueData::set_pollupdateparentkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00001000u;
 _impl_.pollupdateparentkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.MsgOpaqueData.pollUpdateParentKey)
}
inline std::string* MsgOpaqueData::mutable_pollupdateparentkey() {
  std::string* _s = _internal_mutable_pollupdateparentkey();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.pollUpdateParentKey)
  return _s;
}
inline const std::string& MsgOpaqueData::_internal_pollupdateparentkey() const {
  return _impl_.pollupdateparentkey_.Get();
}
inline void MsgOpaqueData::_internal_set_pollupdateparentkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.pollupdateparentkey_.Set(value, GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::_internal_mutable_pollupdateparentkey() {
  _impl_._has_bits_[0] |= 0x00001000u;
  return _impl_.pollupdateparentkey_.Mutable(GetArenaForAllocation());
}
inline std::string* MsgOpaqueData::release_pollupdateparentkey() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.pollUpdateParentKey)
  if (!_internal_has_pollupdateparentkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00001000u;
  auto* p = _impl_.pollupdateparentkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pollupdateparentkey_.IsDefault()) {
    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MsgOpaqueData::set_allocated_pollupdateparentkey(std::string* pollupdateparentkey) {
  if (pollupdateparentkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.pollupdateparentkey_.SetAllocated(pollupdateparentkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pollupdateparentkey_.IsDefault()) {
    _impl_.pollupdateparentkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.pollUpdateParentKey)
}

// optional .proto.PollEncValue encPollVote = 24;
inline bool MsgOpaqueData::_internal_has_encpollvote() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.encpollvote_ != nullptr);
  return value;
}
inline bool MsgOpaqueData::has_encpollvote() const {
  return _internal_has_encpollvote();
}
inline void MsgOpaqueData::clear_encpollvote() {
  if (_impl_.encpollvote_ != nullptr) _impl_.encpollvote_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::PollEncValue& MsgOpaqueData::_internal_encpollvote() const {
  const ::proto::PollEncValue* p = _impl_.encpollvote_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PollEncValue&>(
      ::proto::_PollEncValue_default_instance_);
}
inline const ::proto::PollEncValue& MsgOpaqueData::encpollvote() const {
  // @@protoc_insertion_point(field_get:proto.MsgOpaqueData.encPollVote)
  return _internal_encpollvote();
}
inline void MsgOpaqueData::unsafe_arena_set_allocated_encpollvote(
    ::proto::PollEncValue* encpollvote) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.encpollvote_);
  }
  _impl_.encpollvote_ = encpollvote;
  if (encpollvote) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgOpaqueData.encPollVote)
}
inline ::proto::PollEncValue* MsgOpaqueData::release_encpollvote() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::PollEncValue* temp = _impl_.encpollvote_;
  _impl_.encpollvote_ = 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 ::proto::PollEncValue* MsgOpaqueData::unsafe_arena_release_encpollvote() {
  // @@protoc_insertion_point(field_release:proto.MsgOpaqueData.encPollVote)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::PollEncValue* temp = _impl_.encpollvote_;
  _impl_.encpollvote_ = nullptr;
  return temp;
}
inline ::proto::PollEncValue* MsgOpaqueData::_internal_mutable_encpollvote() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.encpollvote_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PollEncValue>(GetArenaForAllocation());
    _impl_.encpollvote_ = p;
  }
  return _impl_.encpollvote_;
}
inline ::proto::PollEncValue* MsgOpaqueData::mutable_encpollvote() {
  ::proto::PollEncValue* _msg = _internal_mutable_encpollvote();
  // @@protoc_insertion_point(field_mutable:proto.MsgOpaqueData.encPollVote)
  return _msg;
}
inline void MsgOpaqueData::set_allocated_encpollvote(::proto::PollEncValue* encpollvote) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.encpollvote_;
  }
  if (encpollvote) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(encpollvote);
    if (message_arena != submessage_arena) {
      encpollvote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, encpollvote, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.encpollvote_ = encpollvote;
  // @@protoc_insertion_point(field_set_allocated:proto.MsgOpaqueData.encPollVote)
}

// -------------------------------------------------------------------

// MsgRowOpaqueData

// optional .proto.MsgOpaqueData currentMsg = 1;
inline bool MsgRowOpaqueData::_internal_has_currentmsg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.currentmsg_ != nullptr);
  return value;
}
inline bool MsgRowOpaqueData::has_currentmsg() const {
  return _internal_has_currentmsg();
}
inline void MsgRowOpaqueData::clear_currentmsg() {
  if (_impl_.currentmsg_ != nullptr) _impl_.currentmsg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_currentmsg() const {
  const ::proto::MsgOpaqueData* p = _impl_.currentmsg_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MsgOpaqueData&>(
      ::proto::_MsgOpaqueData_default_instance_);
}
inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::currentmsg() const {
  // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.currentMsg)
  return _internal_currentmsg();
}
inline void MsgRowOpaqueData::unsafe_arena_set_allocated_currentmsg(
    ::proto::MsgOpaqueData* currentmsg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentmsg_);
  }
  _impl_.currentmsg_ = currentmsg;
  if (currentmsg) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.currentMsg)
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_currentmsg() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MsgOpaqueData* temp = _impl_.currentmsg_;
  _impl_.currentmsg_ = 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 ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_currentmsg() {
  // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.currentMsg)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MsgOpaqueData* temp = _impl_.currentmsg_;
  _impl_.currentmsg_ = nullptr;
  return temp;
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_currentmsg() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.currentmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation());
    _impl_.currentmsg_ = p;
  }
  return _impl_.currentmsg_;
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_currentmsg() {
  ::proto::MsgOpaqueData* _msg = _internal_mutable_currentmsg();
  // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.currentMsg)
  return _msg;
}
inline void MsgRowOpaqueData::set_allocated_currentmsg(::proto::MsgOpaqueData* currentmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.currentmsg_;
  }
  if (currentmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentmsg);
    if (message_arena != submessage_arena) {
      currentmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, currentmsg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.currentmsg_ = currentmsg;
  // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.currentMsg)
}

// optional .proto.MsgOpaqueData quotedMsg = 2;
inline bool MsgRowOpaqueData::_internal_has_quotedmsg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quotedmsg_ != nullptr);
  return value;
}
inline bool MsgRowOpaqueData::has_quotedmsg() const {
  return _internal_has_quotedmsg();
}
inline void MsgRowOpaqueData::clear_quotedmsg() {
  if (_impl_.quotedmsg_ != nullptr) _impl_.quotedmsg_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::_internal_quotedmsg() const {
  const ::proto::MsgOpaqueData* p = _impl_.quotedmsg_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MsgOpaqueData&>(
      ::proto::_MsgOpaqueData_default_instance_);
}
inline const ::proto::MsgOpaqueData& MsgRowOpaqueData::quotedmsg() const {
  // @@protoc_insertion_point(field_get:proto.MsgRowOpaqueData.quotedMsg)
  return _internal_quotedmsg();
}
inline void MsgRowOpaqueData::unsafe_arena_set_allocated_quotedmsg(
    ::proto::MsgOpaqueData* quotedmsg) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedmsg_);
  }
  _impl_.quotedmsg_ = quotedmsg;
  if (quotedmsg) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.MsgRowOpaqueData.quotedMsg)
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::release_quotedmsg() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_;
  _impl_.quotedmsg_ = 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 ::proto::MsgOpaqueData* MsgRowOpaqueData::unsafe_arena_release_quotedmsg() {
  // @@protoc_insertion_point(field_release:proto.MsgRowOpaqueData.quotedMsg)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MsgOpaqueData* temp = _impl_.quotedmsg_;
  _impl_.quotedmsg_ = nullptr;
  return temp;
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::_internal_mutable_quotedmsg() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quotedmsg_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MsgOpaqueData>(GetArenaForAllocation());
    _impl_.quotedmsg_ = p;
  }
  return _impl_.quotedmsg_;
}
inline ::proto::MsgOpaqueData* MsgRowOpaqueData::mutable_quotedmsg() {
  ::proto::MsgOpaqueData* _msg = _internal_mutable_quotedmsg();
  // @@protoc_insertion_point(field_mutable:proto.MsgRowOpaqueData.quotedMsg)
  return _msg;
}
inline void MsgRowOpaqueData::set_allocated_quotedmsg(::proto::MsgOpaqueData* quotedmsg) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quotedmsg_;
  }
  if (quotedmsg) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedmsg);
    if (message_arena != submessage_arena) {
      quotedmsg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quotedmsg, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quotedmsg_ = quotedmsg;
  // @@protoc_insertion_point(field_set_allocated:proto.MsgRowOpaqueData.quotedMsg)
}

// -------------------------------------------------------------------

// NoiseCertificate_Details

// optional uint32 serial = 1;
inline bool NoiseCertificate_Details::_internal_has_serial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool NoiseCertificate_Details::has_serial() const {
  return _internal_has_serial();
}
inline void NoiseCertificate_Details::clear_serial() {
  _impl_.serial_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t NoiseCertificate_Details::_internal_serial() const {
  return _impl_.serial_;
}
inline uint32_t NoiseCertificate_Details::serial() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.serial)
  return _internal_serial();
}
inline void NoiseCertificate_Details::_internal_set_serial(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.serial_ = value;
}
inline void NoiseCertificate_Details::set_serial(uint32_t value) {
  _internal_set_serial(value);
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.serial)
}

// optional string issuer = 2;
inline bool NoiseCertificate_Details::_internal_has_issuer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NoiseCertificate_Details::has_issuer() const {
  return _internal_has_issuer();
}
inline void NoiseCertificate_Details::clear_issuer() {
  _impl_.issuer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NoiseCertificate_Details::issuer() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.issuer)
  return _internal_issuer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoiseCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.issuer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.issuer)
}
inline std::string* NoiseCertificate_Details::mutable_issuer() {
  std::string* _s = _internal_mutable_issuer();
  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.issuer)
  return _s;
}
inline const std::string& NoiseCertificate_Details::_internal_issuer() const {
  return _impl_.issuer_.Get();
}
inline void NoiseCertificate_Details::_internal_set_issuer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.issuer_.Set(value, GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::_internal_mutable_issuer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.issuer_.Mutable(GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::release_issuer() {
  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.issuer)
  if (!_internal_has_issuer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.issuer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.issuer_.IsDefault()) {
    _impl_.issuer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NoiseCertificate_Details::set_allocated_issuer(std::string* issuer) {
  if (issuer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.issuer_.IsDefault()) {
    _impl_.issuer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.issuer)
}

// optional uint64 expires = 3;
inline bool NoiseCertificate_Details::_internal_has_expires() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NoiseCertificate_Details::has_expires() const {
  return _internal_has_expires();
}
inline void NoiseCertificate_Details::clear_expires() {
  _impl_.expires_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t NoiseCertificate_Details::_internal_expires() const {
  return _impl_.expires_;
}
inline uint64_t NoiseCertificate_Details::expires() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.expires)
  return _internal_expires();
}
inline void NoiseCertificate_Details::_internal_set_expires(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.expires_ = value;
}
inline void NoiseCertificate_Details::set_expires(uint64_t value) {
  _internal_set_expires(value);
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.expires)
}

// optional string subject = 4;
inline bool NoiseCertificate_Details::_internal_has_subject() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NoiseCertificate_Details::has_subject() const {
  return _internal_has_subject();
}
inline void NoiseCertificate_Details::clear_subject() {
  _impl_.subject_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NoiseCertificate_Details::subject() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.subject)
  return _internal_subject();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoiseCertificate_Details::set_subject(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.subject_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.subject)
}
inline std::string* NoiseCertificate_Details::mutable_subject() {
  std::string* _s = _internal_mutable_subject();
  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.subject)
  return _s;
}
inline const std::string& NoiseCertificate_Details::_internal_subject() const {
  return _impl_.subject_.Get();
}
inline void NoiseCertificate_Details::_internal_set_subject(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.subject_.Set(value, GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::_internal_mutable_subject() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.subject_.Mutable(GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::release_subject() {
  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.subject)
  if (!_internal_has_subject()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.subject_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.subject_.IsDefault()) {
    _impl_.subject_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NoiseCertificate_Details::set_allocated_subject(std::string* subject) {
  if (subject != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.subject_.SetAllocated(subject, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.subject_.IsDefault()) {
    _impl_.subject_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.Details.subject)
}

// optional bytes key = 5;
inline bool NoiseCertificate_Details::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool NoiseCertificate_Details::has_key() const {
  return _internal_has_key();
}
inline void NoiseCertificate_Details::clear_key() {
  _impl_.key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& NoiseCertificate_Details::key() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.Details.key)
  return _internal_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoiseCertificate_Details::set_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.Details.key)
}
inline std::string* NoiseCertificate_Details::mutable_key() {
  std::string* _s = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.Details.key)
  return _s;
}
inline const std::string& NoiseCertificate_Details::_internal_key() const {
  return _impl_.key_.Get();
}
inline void NoiseCertificate_Details::_internal_set_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.key_.Set(value, GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.key_.Mutable(GetArenaForAllocation());
}
inline std::string* NoiseCertificate_Details::release_key() {
  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.Details.key)
  if (!_internal_has_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  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 NoiseCertificate_Details::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _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:proto.NoiseCertificate.Details.key)
}

// -------------------------------------------------------------------

// NoiseCertificate

// optional bytes details = 1;
inline bool NoiseCertificate::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NoiseCertificate::has_details() const {
  return _internal_has_details();
}
inline void NoiseCertificate::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NoiseCertificate::details() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoiseCertificate::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.details)
}
inline std::string* NoiseCertificate::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.details)
  return _s;
}
inline const std::string& NoiseCertificate::_internal_details() const {
  return _impl_.details_.Get();
}
inline void NoiseCertificate::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* NoiseCertificate::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* NoiseCertificate::release_details() {
  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NoiseCertificate::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.details)
}

// optional bytes signature = 2;
inline bool NoiseCertificate::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool NoiseCertificate::has_signature() const {
  return _internal_has_signature();
}
inline void NoiseCertificate::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& NoiseCertificate::signature() const {
  // @@protoc_insertion_point(field_get:proto.NoiseCertificate.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NoiseCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NoiseCertificate.signature)
}
inline std::string* NoiseCertificate::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:proto.NoiseCertificate.signature)
  return _s;
}
inline const std::string& NoiseCertificate::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void NoiseCertificate::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* NoiseCertificate::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* NoiseCertificate::release_signature() {
  // @@protoc_insertion_point(field_release:proto.NoiseCertificate.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.signature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NoiseCertificate::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.NoiseCertificate.signature)
}

// -------------------------------------------------------------------

// NotificationMessageInfo

// optional .proto.MessageKey key = 1;
inline bool NotificationMessageInfo::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool NotificationMessageInfo::has_key() const {
  return _internal_has_key();
}
inline void NotificationMessageInfo::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::MessageKey& NotificationMessageInfo::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& NotificationMessageInfo::key() const {
  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.key)
  return _internal_key();
}
inline void NotificationMessageInfo::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.key)
}
inline ::proto::MessageKey* NotificationMessageInfo::release_key() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* NotificationMessageInfo::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.key)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* NotificationMessageInfo::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* NotificationMessageInfo::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.key)
  return _msg;
}
inline void NotificationMessageInfo::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.key)
}

// optional .proto.Message message = 2;
inline bool NotificationMessageInfo::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
  return value;
}
inline bool NotificationMessageInfo::has_message() const {
  return _internal_has_message();
}
inline void NotificationMessageInfo::clear_message() {
  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::Message& NotificationMessageInfo::_internal_message() const {
  const ::proto::Message* p = _impl_.message_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& NotificationMessageInfo::message() const {
  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.message)
  return _internal_message();
}
inline void NotificationMessageInfo::unsafe_arena_set_allocated_message(
    ::proto::Message* message) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
  }
  _impl_.message_ = message;
  if (message) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.NotificationMessageInfo.message)
}
inline ::proto::Message* NotificationMessageInfo::release_message() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = 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 ::proto::Message* NotificationMessageInfo::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.message)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = nullptr;
  return temp;
}
inline ::proto::Message* NotificationMessageInfo::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.message_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.message_ = p;
  }
  return _impl_.message_;
}
inline ::proto::Message* NotificationMessageInfo::mutable_message() {
  ::proto::Message* _msg = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.message)
  return _msg;
}
inline void NotificationMessageInfo::set_allocated_message(::proto::Message* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.message_ = message;
  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.message)
}

// optional uint64 messageTimestamp = 3;
inline bool NotificationMessageInfo::_internal_has_messagetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool NotificationMessageInfo::has_messagetimestamp() const {
  return _internal_has_messagetimestamp();
}
inline void NotificationMessageInfo::clear_messagetimestamp() {
  _impl_.messagetimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t NotificationMessageInfo::_internal_messagetimestamp() const {
  return _impl_.messagetimestamp_;
}
inline uint64_t NotificationMessageInfo::messagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.messageTimestamp)
  return _internal_messagetimestamp();
}
inline void NotificationMessageInfo::_internal_set_messagetimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.messagetimestamp_ = value;
}
inline void NotificationMessageInfo::set_messagetimestamp(uint64_t value) {
  _internal_set_messagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.messageTimestamp)
}

// optional string participant = 4;
inline bool NotificationMessageInfo::_internal_has_participant() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool NotificationMessageInfo::has_participant() const {
  return _internal_has_participant();
}
inline void NotificationMessageInfo::clear_participant() {
  _impl_.participant_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& NotificationMessageInfo::participant() const {
  // @@protoc_insertion_point(field_get:proto.NotificationMessageInfo.participant)
  return _internal_participant();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NotificationMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.NotificationMessageInfo.participant)
}
inline std::string* NotificationMessageInfo::mutable_participant() {
  std::string* _s = _internal_mutable_participant();
  // @@protoc_insertion_point(field_mutable:proto.NotificationMessageInfo.participant)
  return _s;
}
inline const std::string& NotificationMessageInfo::_internal_participant() const {
  return _impl_.participant_.Get();
}
inline void NotificationMessageInfo::_internal_set_participant(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.participant_.Set(value, GetArenaForAllocation());
}
inline std::string* NotificationMessageInfo::_internal_mutable_participant() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.participant_.Mutable(GetArenaForAllocation());
}
inline std::string* NotificationMessageInfo::release_participant() {
  // @@protoc_insertion_point(field_release:proto.NotificationMessageInfo.participant)
  if (!_internal_has_participant()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.participant_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void NotificationMessageInfo::set_allocated_participant(std::string* participant) {
  if (participant != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.NotificationMessageInfo.participant)
}

// -------------------------------------------------------------------

// PastParticipant

// required string userJid = 1;
inline bool PastParticipant::_internal_has_userjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PastParticipant::has_userjid() const {
  return _internal_has_userjid();
}
inline void PastParticipant::clear_userjid() {
  _impl_.userjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PastParticipant::userjid() const {
  // @@protoc_insertion_point(field_get:proto.PastParticipant.userJid)
  return _internal_userjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PastParticipant::set_userjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PastParticipant.userJid)
}
inline std::string* PastParticipant::mutable_userjid() {
  std::string* _s = _internal_mutable_userjid();
  // @@protoc_insertion_point(field_mutable:proto.PastParticipant.userJid)
  return _s;
}
inline const std::string& PastParticipant::_internal_userjid() const {
  return _impl_.userjid_.Get();
}
inline void PastParticipant::_internal_set_userjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.userjid_.Set(value, GetArenaForAllocation());
}
inline std::string* PastParticipant::_internal_mutable_userjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.userjid_.Mutable(GetArenaForAllocation());
}
inline std::string* PastParticipant::release_userjid() {
  // @@protoc_insertion_point(field_release:proto.PastParticipant.userJid)
  if (!_internal_has_userjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.userjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PastParticipant::set_allocated_userjid(std::string* userjid) {
  if (userjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PastParticipant.userJid)
}

// required .proto.PastParticipant.LeaveReason leaveReason = 2;
inline bool PastParticipant::_internal_has_leavereason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PastParticipant::has_leavereason() const {
  return _internal_has_leavereason();
}
inline void PastParticipant::clear_leavereason() {
  _impl_.leavereason_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::PastParticipant_LeaveReason PastParticipant::_internal_leavereason() const {
  return static_cast< ::proto::PastParticipant_LeaveReason >(_impl_.leavereason_);
}
inline ::proto::PastParticipant_LeaveReason PastParticipant::leavereason() const {
  // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveReason)
  return _internal_leavereason();
}
inline void PastParticipant::_internal_set_leavereason(::proto::PastParticipant_LeaveReason value) {
  assert(::proto::PastParticipant_LeaveReason_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.leavereason_ = value;
}
inline void PastParticipant::set_leavereason(::proto::PastParticipant_LeaveReason value) {
  _internal_set_leavereason(value);
  // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveReason)
}

// required uint64 leaveTs = 3;
inline bool PastParticipant::_internal_has_leavets() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PastParticipant::has_leavets() const {
  return _internal_has_leavets();
}
inline void PastParticipant::clear_leavets() {
  _impl_.leavets_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t PastParticipant::_internal_leavets() const {
  return _impl_.leavets_;
}
inline uint64_t PastParticipant::leavets() const {
  // @@protoc_insertion_point(field_get:proto.PastParticipant.leaveTs)
  return _internal_leavets();
}
inline void PastParticipant::_internal_set_leavets(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.leavets_ = value;
}
inline void PastParticipant::set_leavets(uint64_t value) {
  _internal_set_leavets(value);
  // @@protoc_insertion_point(field_set:proto.PastParticipant.leaveTs)
}

// -------------------------------------------------------------------

// PastParticipants

// required string groupJid = 1;
inline bool PastParticipants::_internal_has_groupjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PastParticipants::has_groupjid() const {
  return _internal_has_groupjid();
}
inline void PastParticipants::clear_groupjid() {
  _impl_.groupjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PastParticipants::groupjid() const {
  // @@protoc_insertion_point(field_get:proto.PastParticipants.groupJid)
  return _internal_groupjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PastParticipants::set_groupjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.groupjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PastParticipants.groupJid)
}
inline std::string* PastParticipants::mutable_groupjid() {
  std::string* _s = _internal_mutable_groupjid();
  // @@protoc_insertion_point(field_mutable:proto.PastParticipants.groupJid)
  return _s;
}
inline const std::string& PastParticipants::_internal_groupjid() const {
  return _impl_.groupjid_.Get();
}
inline void PastParticipants::_internal_set_groupjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.groupjid_.Set(value, GetArenaForAllocation());
}
inline std::string* PastParticipants::_internal_mutable_groupjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.groupjid_.Mutable(GetArenaForAllocation());
}
inline std::string* PastParticipants::release_groupjid() {
  // @@protoc_insertion_point(field_release:proto.PastParticipants.groupJid)
  if (!_internal_has_groupjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.groupjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupjid_.IsDefault()) {
    _impl_.groupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PastParticipants::set_allocated_groupjid(std::string* groupjid) {
  if (groupjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.groupjid_.SetAllocated(groupjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupjid_.IsDefault()) {
    _impl_.groupjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PastParticipants.groupJid)
}

// repeated .proto.PastParticipant pastParticipants = 2;
inline int PastParticipants::_internal_pastparticipants_size() const {
  return _impl_.pastparticipants_.size();
}
inline int PastParticipants::pastparticipants_size() const {
  return _internal_pastparticipants_size();
}
inline void PastParticipants::clear_pastparticipants() {
  _impl_.pastparticipants_.Clear();
}
inline ::proto::PastParticipant* PastParticipants::mutable_pastparticipants(int index) {
  // @@protoc_insertion_point(field_mutable:proto.PastParticipants.pastParticipants)
  return _impl_.pastparticipants_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >*
PastParticipants::mutable_pastparticipants() {
  // @@protoc_insertion_point(field_mutable_list:proto.PastParticipants.pastParticipants)
  return &_impl_.pastparticipants_;
}
inline const ::proto::PastParticipant& PastParticipants::_internal_pastparticipants(int index) const {
  return _impl_.pastparticipants_.Get(index);
}
inline const ::proto::PastParticipant& PastParticipants::pastparticipants(int index) const {
  // @@protoc_insertion_point(field_get:proto.PastParticipants.pastParticipants)
  return _internal_pastparticipants(index);
}
inline ::proto::PastParticipant* PastParticipants::_internal_add_pastparticipants() {
  return _impl_.pastparticipants_.Add();
}
inline ::proto::PastParticipant* PastParticipants::add_pastparticipants() {
  ::proto::PastParticipant* _add = _internal_add_pastparticipants();
  // @@protoc_insertion_point(field_add:proto.PastParticipants.pastParticipants)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PastParticipant >&
PastParticipants::pastparticipants() const {
  // @@protoc_insertion_point(field_list:proto.PastParticipants.pastParticipants)
  return _impl_.pastparticipants_;
}

// -------------------------------------------------------------------

// PaymentBackground_MediaData

// optional bytes mediaKey = 1;
inline bool PaymentBackground_MediaData::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PaymentBackground_MediaData::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void PaymentBackground_MediaData::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PaymentBackground_MediaData::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground_MediaData::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKey)
}
inline std::string* PaymentBackground_MediaData::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.mediaKey)
  return _s;
}
inline const std::string& PaymentBackground_MediaData::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void PaymentBackground_MediaData::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground_MediaData::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.mediaKey)
}

// optional int64 mediaKeyTimestamp = 2;
inline bool PaymentBackground_MediaData::_internal_has_mediakeytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PaymentBackground_MediaData::has_mediakeytimestamp() const {
  return _internal_has_mediakeytimestamp();
}
inline void PaymentBackground_MediaData::clear_mediakeytimestamp() {
  _impl_.mediakeytimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline int64_t PaymentBackground_MediaData::_internal_mediakeytimestamp() const {
  return _impl_.mediakeytimestamp_;
}
inline int64_t PaymentBackground_MediaData::mediakeytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.mediaKeyTimestamp)
  return _internal_mediakeytimestamp();
}
inline void PaymentBackground_MediaData::_internal_set_mediakeytimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mediakeytimestamp_ = value;
}
inline void PaymentBackground_MediaData::set_mediakeytimestamp(int64_t value) {
  _internal_set_mediakeytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.mediaKeyTimestamp)
}

// optional bytes fileSha256 = 3;
inline bool PaymentBackground_MediaData::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PaymentBackground_MediaData::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void PaymentBackground_MediaData::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PaymentBackground_MediaData::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground_MediaData::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileSha256)
}
inline std::string* PaymentBackground_MediaData::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileSha256)
  return _s;
}
inline const std::string& PaymentBackground_MediaData::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void PaymentBackground_MediaData::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground_MediaData::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileSha256)
}

// optional bytes fileEncSha256 = 4;
inline bool PaymentBackground_MediaData::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PaymentBackground_MediaData::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void PaymentBackground_MediaData::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PaymentBackground_MediaData::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground_MediaData::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.fileEncSha256)
}
inline std::string* PaymentBackground_MediaData::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.fileEncSha256)
  return _s;
}
inline const std::string& PaymentBackground_MediaData::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void PaymentBackground_MediaData::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground_MediaData::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.fileEncSha256)
}

// optional string directPath = 5;
inline bool PaymentBackground_MediaData::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PaymentBackground_MediaData::has_directpath() const {
  return _internal_has_directpath();
}
inline void PaymentBackground_MediaData::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& PaymentBackground_MediaData::directpath() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.MediaData.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground_MediaData::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.MediaData.directPath)
}
inline std::string* PaymentBackground_MediaData::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.MediaData.directPath)
  return _s;
}
inline const std::string& PaymentBackground_MediaData::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void PaymentBackground_MediaData::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground_MediaData::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.MediaData.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground_MediaData::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.MediaData.directPath)
}

// -------------------------------------------------------------------

// PaymentBackground

// optional string id = 1;
inline bool PaymentBackground::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PaymentBackground::has_id() const {
  return _internal_has_id();
}
inline void PaymentBackground::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PaymentBackground::id() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.id)
}
inline std::string* PaymentBackground::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.id)
  return _s;
}
inline const std::string& PaymentBackground::_internal_id() const {
  return _impl_.id_.Get();
}
inline void PaymentBackground::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground::release_id() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.id)
}

// optional uint64 fileLength = 2;
inline bool PaymentBackground::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PaymentBackground::has_filelength() const {
  return _internal_has_filelength();
}
inline void PaymentBackground::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t PaymentBackground::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t PaymentBackground::filelength() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.fileLength)
  return _internal_filelength();
}
inline void PaymentBackground::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.filelength_ = value;
}
inline void PaymentBackground::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.fileLength)
}

// optional uint32 width = 3;
inline bool PaymentBackground::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PaymentBackground::has_width() const {
  return _internal_has_width();
}
inline void PaymentBackground::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t PaymentBackground::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t PaymentBackground::width() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.width)
  return _internal_width();
}
inline void PaymentBackground::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.width_ = value;
}
inline void PaymentBackground::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.width)
}

// optional uint32 height = 4;
inline bool PaymentBackground::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool PaymentBackground::has_height() const {
  return _internal_has_height();
}
inline void PaymentBackground::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t PaymentBackground::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t PaymentBackground::height() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.height)
  return _internal_height();
}
inline void PaymentBackground::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.height_ = value;
}
inline void PaymentBackground::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.height)
}

// optional string mimetype = 5;
inline bool PaymentBackground::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PaymentBackground::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void PaymentBackground::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PaymentBackground::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentBackground::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.mimetype)
}
inline std::string* PaymentBackground::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mimetype)
  return _s;
}
inline const std::string& PaymentBackground::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void PaymentBackground::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentBackground::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentBackground::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentBackground::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mimetype)
}

// optional fixed32 placeholderArgb = 6;
inline bool PaymentBackground::_internal_has_placeholderargb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool PaymentBackground::has_placeholderargb() const {
  return _internal_has_placeholderargb();
}
inline void PaymentBackground::clear_placeholderargb() {
  _impl_.placeholderargb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t PaymentBackground::_internal_placeholderargb() const {
  return _impl_.placeholderargb_;
}
inline uint32_t PaymentBackground::placeholderargb() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.placeholderArgb)
  return _internal_placeholderargb();
}
inline void PaymentBackground::_internal_set_placeholderargb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.placeholderargb_ = value;
}
inline void PaymentBackground::set_placeholderargb(uint32_t value) {
  _internal_set_placeholderargb(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.placeholderArgb)
}

// optional fixed32 textArgb = 7;
inline bool PaymentBackground::_internal_has_textargb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool PaymentBackground::has_textargb() const {
  return _internal_has_textargb();
}
inline void PaymentBackground::clear_textargb() {
  _impl_.textargb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t PaymentBackground::_internal_textargb() const {
  return _impl_.textargb_;
}
inline uint32_t PaymentBackground::textargb() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.textArgb)
  return _internal_textargb();
}
inline void PaymentBackground::_internal_set_textargb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.textargb_ = value;
}
inline void PaymentBackground::set_textargb(uint32_t value) {
  _internal_set_textargb(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.textArgb)
}

// optional fixed32 subtextArgb = 8;
inline bool PaymentBackground::_internal_has_subtextargb() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool PaymentBackground::has_subtextargb() const {
  return _internal_has_subtextargb();
}
inline void PaymentBackground::clear_subtextargb() {
  _impl_.subtextargb_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t PaymentBackground::_internal_subtextargb() const {
  return _impl_.subtextargb_;
}
inline uint32_t PaymentBackground::subtextargb() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.subtextArgb)
  return _internal_subtextargb();
}
inline void PaymentBackground::_internal_set_subtextargb(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.subtextargb_ = value;
}
inline void PaymentBackground::set_subtextargb(uint32_t value) {
  _internal_set_subtextargb(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.subtextArgb)
}

// optional .proto.PaymentBackground.MediaData mediaData = 9;
inline bool PaymentBackground::_internal_has_mediadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr);
  return value;
}
inline bool PaymentBackground::has_mediadata() const {
  return _internal_has_mediadata();
}
inline void PaymentBackground::clear_mediadata() {
  if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::PaymentBackground_MediaData& PaymentBackground::_internal_mediadata() const {
  const ::proto::PaymentBackground_MediaData* p = _impl_.mediadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentBackground_MediaData&>(
      ::proto::_PaymentBackground_MediaData_default_instance_);
}
inline const ::proto::PaymentBackground_MediaData& PaymentBackground::mediadata() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.mediaData)
  return _internal_mediadata();
}
inline void PaymentBackground::unsafe_arena_set_allocated_mediadata(
    ::proto::PaymentBackground_MediaData* mediadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_);
  }
  _impl_.mediadata_ = mediadata;
  if (mediadata) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentBackground.mediaData)
}
inline ::proto::PaymentBackground_MediaData* PaymentBackground::release_mediadata() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_;
  _impl_.mediadata_ = 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 ::proto::PaymentBackground_MediaData* PaymentBackground::unsafe_arena_release_mediadata() {
  // @@protoc_insertion_point(field_release:proto.PaymentBackground.mediaData)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::PaymentBackground_MediaData* temp = _impl_.mediadata_;
  _impl_.mediadata_ = nullptr;
  return temp;
}
inline ::proto::PaymentBackground_MediaData* PaymentBackground::_internal_mutable_mediadata() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.mediadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PaymentBackground_MediaData>(GetArenaForAllocation());
    _impl_.mediadata_ = p;
  }
  return _impl_.mediadata_;
}
inline ::proto::PaymentBackground_MediaData* PaymentBackground::mutable_mediadata() {
  ::proto::PaymentBackground_MediaData* _msg = _internal_mutable_mediadata();
  // @@protoc_insertion_point(field_mutable:proto.PaymentBackground.mediaData)
  return _msg;
}
inline void PaymentBackground::set_allocated_mediadata(::proto::PaymentBackground_MediaData* mediadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.mediadata_;
  }
  if (mediadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata);
    if (message_arena != submessage_arena) {
      mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mediadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.mediadata_ = mediadata;
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentBackground.mediaData)
}

// optional .proto.PaymentBackground.Type type = 10;
inline bool PaymentBackground::_internal_has_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool PaymentBackground::has_type() const {
  return _internal_has_type();
}
inline void PaymentBackground::clear_type() {
  _impl_.type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::proto::PaymentBackground_Type PaymentBackground::_internal_type() const {
  return static_cast< ::proto::PaymentBackground_Type >(_impl_.type_);
}
inline ::proto::PaymentBackground_Type PaymentBackground::type() const {
  // @@protoc_insertion_point(field_get:proto.PaymentBackground.type)
  return _internal_type();
}
inline void PaymentBackground::_internal_set_type(::proto::PaymentBackground_Type value) {
  assert(::proto::PaymentBackground_Type_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.type_ = value;
}
inline void PaymentBackground::set_type(::proto::PaymentBackground_Type value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:proto.PaymentBackground.type)
}

// -------------------------------------------------------------------

// PaymentInfo

// optional .proto.PaymentInfo.Currency currencyDeprecated = 1;
inline bool PaymentInfo::_internal_has_currencydeprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool PaymentInfo::has_currencydeprecated() const {
  return _internal_has_currencydeprecated();
}
inline void PaymentInfo::clear_currencydeprecated() {
  _impl_.currencydeprecated_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::proto::PaymentInfo_Currency PaymentInfo::_internal_currencydeprecated() const {
  return static_cast< ::proto::PaymentInfo_Currency >(_impl_.currencydeprecated_);
}
inline ::proto::PaymentInfo_Currency PaymentInfo::currencydeprecated() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.currencyDeprecated)
  return _internal_currencydeprecated();
}
inline void PaymentInfo::_internal_set_currencydeprecated(::proto::PaymentInfo_Currency value) {
  assert(::proto::PaymentInfo_Currency_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.currencydeprecated_ = value;
}
inline void PaymentInfo::set_currencydeprecated(::proto::PaymentInfo_Currency value) {
  _internal_set_currencydeprecated(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.currencyDeprecated)
}

// optional uint64 amount1000 = 2;
inline bool PaymentInfo::_internal_has_amount1000() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool PaymentInfo::has_amount1000() const {
  return _internal_has_amount1000();
}
inline void PaymentInfo::clear_amount1000() {
  _impl_.amount1000_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t PaymentInfo::_internal_amount1000() const {
  return _impl_.amount1000_;
}
inline uint64_t PaymentInfo::amount1000() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.amount1000)
  return _internal_amount1000();
}
inline void PaymentInfo::_internal_set_amount1000(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.amount1000_ = value;
}
inline void PaymentInfo::set_amount1000(uint64_t value) {
  _internal_set_amount1000(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.amount1000)
}

// optional string receiverJid = 3;
inline bool PaymentInfo::_internal_has_receiverjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PaymentInfo::has_receiverjid() const {
  return _internal_has_receiverjid();
}
inline void PaymentInfo::clear_receiverjid() {
  _impl_.receiverjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PaymentInfo::receiverjid() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.receiverJid)
  return _internal_receiverjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentInfo::set_receiverjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.receiverjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.receiverJid)
}
inline std::string* PaymentInfo::mutable_receiverjid() {
  std::string* _s = _internal_mutable_receiverjid();
  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.receiverJid)
  return _s;
}
inline const std::string& PaymentInfo::_internal_receiverjid() const {
  return _impl_.receiverjid_.Get();
}
inline void PaymentInfo::_internal_set_receiverjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.receiverjid_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentInfo::_internal_mutable_receiverjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.receiverjid_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentInfo::release_receiverjid() {
  // @@protoc_insertion_point(field_release:proto.PaymentInfo.receiverJid)
  if (!_internal_has_receiverjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.receiverjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.receiverjid_.IsDefault()) {
    _impl_.receiverjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentInfo::set_allocated_receiverjid(std::string* receiverjid) {
  if (receiverjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.receiverjid_.SetAllocated(receiverjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.receiverjid_.IsDefault()) {
    _impl_.receiverjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.receiverJid)
}

// optional .proto.PaymentInfo.Status status = 4;
inline bool PaymentInfo::_internal_has_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool PaymentInfo::has_status() const {
  return _internal_has_status();
}
inline void PaymentInfo::clear_status() {
  _impl_.status_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::proto::PaymentInfo_Status PaymentInfo::_internal_status() const {
  return static_cast< ::proto::PaymentInfo_Status >(_impl_.status_);
}
inline ::proto::PaymentInfo_Status PaymentInfo::status() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.status)
  return _internal_status();
}
inline void PaymentInfo::_internal_set_status(::proto::PaymentInfo_Status value) {
  assert(::proto::PaymentInfo_Status_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.status_ = value;
}
inline void PaymentInfo::set_status(::proto::PaymentInfo_Status value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.status)
}

// optional uint64 transactionTimestamp = 5;
inline bool PaymentInfo::_internal_has_transactiontimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool PaymentInfo::has_transactiontimestamp() const {
  return _internal_has_transactiontimestamp();
}
inline void PaymentInfo::clear_transactiontimestamp() {
  _impl_.transactiontimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t PaymentInfo::_internal_transactiontimestamp() const {
  return _impl_.transactiontimestamp_;
}
inline uint64_t PaymentInfo::transactiontimestamp() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.transactionTimestamp)
  return _internal_transactiontimestamp();
}
inline void PaymentInfo::_internal_set_transactiontimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.transactiontimestamp_ = value;
}
inline void PaymentInfo::set_transactiontimestamp(uint64_t value) {
  _internal_set_transactiontimestamp(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.transactionTimestamp)
}

// optional .proto.MessageKey requestMessageKey = 6;
inline bool PaymentInfo::_internal_has_requestmessagekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.requestmessagekey_ != nullptr);
  return value;
}
inline bool PaymentInfo::has_requestmessagekey() const {
  return _internal_has_requestmessagekey();
}
inline void PaymentInfo::clear_requestmessagekey() {
  if (_impl_.requestmessagekey_ != nullptr) _impl_.requestmessagekey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::MessageKey& PaymentInfo::_internal_requestmessagekey() const {
  const ::proto::MessageKey* p = _impl_.requestmessagekey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& PaymentInfo::requestmessagekey() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.requestMessageKey)
  return _internal_requestmessagekey();
}
inline void PaymentInfo::unsafe_arena_set_allocated_requestmessagekey(
    ::proto::MessageKey* requestmessagekey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.requestmessagekey_);
  }
  _impl_.requestmessagekey_ = requestmessagekey;
  if (requestmessagekey) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.requestMessageKey)
}
inline ::proto::MessageKey* PaymentInfo::release_requestmessagekey() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
  _impl_.requestmessagekey_ = 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 ::proto::MessageKey* PaymentInfo::unsafe_arena_release_requestmessagekey() {
  // @@protoc_insertion_point(field_release:proto.PaymentInfo.requestMessageKey)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.requestmessagekey_;
  _impl_.requestmessagekey_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* PaymentInfo::_internal_mutable_requestmessagekey() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.requestmessagekey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.requestmessagekey_ = p;
  }
  return _impl_.requestmessagekey_;
}
inline ::proto::MessageKey* PaymentInfo::mutable_requestmessagekey() {
  ::proto::MessageKey* _msg = _internal_mutable_requestmessagekey();
  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.requestMessageKey)
  return _msg;
}
inline void PaymentInfo::set_allocated_requestmessagekey(::proto::MessageKey* requestmessagekey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.requestmessagekey_;
  }
  if (requestmessagekey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(requestmessagekey);
    if (message_arena != submessage_arena) {
      requestmessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestmessagekey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.requestmessagekey_ = requestmessagekey;
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.requestMessageKey)
}

// optional uint64 expiryTimestamp = 7;
inline bool PaymentInfo::_internal_has_expirytimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool PaymentInfo::has_expirytimestamp() const {
  return _internal_has_expirytimestamp();
}
inline void PaymentInfo::clear_expirytimestamp() {
  _impl_.expirytimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t PaymentInfo::_internal_expirytimestamp() const {
  return _impl_.expirytimestamp_;
}
inline uint64_t PaymentInfo::expirytimestamp() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.expiryTimestamp)
  return _internal_expirytimestamp();
}
inline void PaymentInfo::_internal_set_expirytimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.expirytimestamp_ = value;
}
inline void PaymentInfo::set_expirytimestamp(uint64_t value) {
  _internal_set_expirytimestamp(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.expiryTimestamp)
}

// optional bool futureproofed = 8;
inline bool PaymentInfo::_internal_has_futureproofed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool PaymentInfo::has_futureproofed() const {
  return _internal_has_futureproofed();
}
inline void PaymentInfo::clear_futureproofed() {
  _impl_.futureproofed_ = false;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline bool PaymentInfo::_internal_futureproofed() const {
  return _impl_.futureproofed_;
}
inline bool PaymentInfo::futureproofed() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.futureproofed)
  return _internal_futureproofed();
}
inline void PaymentInfo::_internal_set_futureproofed(bool value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.futureproofed_ = value;
}
inline void PaymentInfo::set_futureproofed(bool value) {
  _internal_set_futureproofed(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.futureproofed)
}

// optional string currency = 9;
inline bool PaymentInfo::_internal_has_currency() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PaymentInfo::has_currency() const {
  return _internal_has_currency();
}
inline void PaymentInfo::clear_currency() {
  _impl_.currency_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PaymentInfo::currency() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.currency)
  return _internal_currency();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PaymentInfo::set_currency(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.currency_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.currency)
}
inline std::string* PaymentInfo::mutable_currency() {
  std::string* _s = _internal_mutable_currency();
  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.currency)
  return _s;
}
inline const std::string& PaymentInfo::_internal_currency() const {
  return _impl_.currency_.Get();
}
inline void PaymentInfo::_internal_set_currency(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.currency_.Set(value, GetArenaForAllocation());
}
inline std::string* PaymentInfo::_internal_mutable_currency() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.currency_.Mutable(GetArenaForAllocation());
}
inline std::string* PaymentInfo::release_currency() {
  // @@protoc_insertion_point(field_release:proto.PaymentInfo.currency)
  if (!_internal_has_currency()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.currency_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currency_.IsDefault()) {
    _impl_.currency_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PaymentInfo::set_allocated_currency(std::string* currency) {
  if (currency != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.currency_.SetAllocated(currency, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.currency_.IsDefault()) {
    _impl_.currency_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.currency)
}

// optional .proto.PaymentInfo.TxnStatus txnStatus = 10;
inline bool PaymentInfo::_internal_has_txnstatus() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool PaymentInfo::has_txnstatus() const {
  return _internal_has_txnstatus();
}
inline void PaymentInfo::clear_txnstatus() {
  _impl_.txnstatus_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::proto::PaymentInfo_TxnStatus PaymentInfo::_internal_txnstatus() const {
  return static_cast< ::proto::PaymentInfo_TxnStatus >(_impl_.txnstatus_);
}
inline ::proto::PaymentInfo_TxnStatus PaymentInfo::txnstatus() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.txnStatus)
  return _internal_txnstatus();
}
inline void PaymentInfo::_internal_set_txnstatus(::proto::PaymentInfo_TxnStatus value) {
  assert(::proto::PaymentInfo_TxnStatus_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.txnstatus_ = value;
}
inline void PaymentInfo::set_txnstatus(::proto::PaymentInfo_TxnStatus value) {
  _internal_set_txnstatus(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.txnStatus)
}

// optional bool useNoviFiatFormat = 11;
inline bool PaymentInfo::_internal_has_usenovifiatformat() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool PaymentInfo::has_usenovifiatformat() const {
  return _internal_has_usenovifiatformat();
}
inline void PaymentInfo::clear_usenovifiatformat() {
  _impl_.usenovifiatformat_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool PaymentInfo::_internal_usenovifiatformat() const {
  return _impl_.usenovifiatformat_;
}
inline bool PaymentInfo::usenovifiatformat() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.useNoviFiatFormat)
  return _internal_usenovifiatformat();
}
inline void PaymentInfo::_internal_set_usenovifiatformat(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.usenovifiatformat_ = value;
}
inline void PaymentInfo::set_usenovifiatformat(bool value) {
  _internal_set_usenovifiatformat(value);
  // @@protoc_insertion_point(field_set:proto.PaymentInfo.useNoviFiatFormat)
}

// optional .proto.Money primaryAmount = 12;
inline bool PaymentInfo::_internal_has_primaryamount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.primaryamount_ != nullptr);
  return value;
}
inline bool PaymentInfo::has_primaryamount() const {
  return _internal_has_primaryamount();
}
inline void PaymentInfo::clear_primaryamount() {
  if (_impl_.primaryamount_ != nullptr) _impl_.primaryamount_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::Money& PaymentInfo::_internal_primaryamount() const {
  const ::proto::Money* p = _impl_.primaryamount_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
      ::proto::_Money_default_instance_);
}
inline const ::proto::Money& PaymentInfo::primaryamount() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.primaryAmount)
  return _internal_primaryamount();
}
inline void PaymentInfo::unsafe_arena_set_allocated_primaryamount(
    ::proto::Money* primaryamount) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryamount_);
  }
  _impl_.primaryamount_ = primaryamount;
  if (primaryamount) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.primaryAmount)
}
inline ::proto::Money* PaymentInfo::release_primaryamount() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Money* temp = _impl_.primaryamount_;
  _impl_.primaryamount_ = 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 ::proto::Money* PaymentInfo::unsafe_arena_release_primaryamount() {
  // @@protoc_insertion_point(field_release:proto.PaymentInfo.primaryAmount)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::Money* temp = _impl_.primaryamount_;
  _impl_.primaryamount_ = nullptr;
  return temp;
}
inline ::proto::Money* PaymentInfo::_internal_mutable_primaryamount() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.primaryamount_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
    _impl_.primaryamount_ = p;
  }
  return _impl_.primaryamount_;
}
inline ::proto::Money* PaymentInfo::mutable_primaryamount() {
  ::proto::Money* _msg = _internal_mutable_primaryamount();
  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.primaryAmount)
  return _msg;
}
inline void PaymentInfo::set_allocated_primaryamount(::proto::Money* primaryamount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.primaryamount_;
  }
  if (primaryamount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryamount);
    if (message_arena != submessage_arena) {
      primaryamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, primaryamount, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.primaryamount_ = primaryamount;
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.primaryAmount)
}

// optional .proto.Money exchangeAmount = 13;
inline bool PaymentInfo::_internal_has_exchangeamount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.exchangeamount_ != nullptr);
  return value;
}
inline bool PaymentInfo::has_exchangeamount() const {
  return _internal_has_exchangeamount();
}
inline void PaymentInfo::clear_exchangeamount() {
  if (_impl_.exchangeamount_ != nullptr) _impl_.exchangeamount_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Money& PaymentInfo::_internal_exchangeamount() const {
  const ::proto::Money* p = _impl_.exchangeamount_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Money&>(
      ::proto::_Money_default_instance_);
}
inline const ::proto::Money& PaymentInfo::exchangeamount() const {
  // @@protoc_insertion_point(field_get:proto.PaymentInfo.exchangeAmount)
  return _internal_exchangeamount();
}
inline void PaymentInfo::unsafe_arena_set_allocated_exchangeamount(
    ::proto::Money* exchangeamount) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exchangeamount_);
  }
  _impl_.exchangeamount_ = exchangeamount;
  if (exchangeamount) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PaymentInfo.exchangeAmount)
}
inline ::proto::Money* PaymentInfo::release_exchangeamount() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Money* temp = _impl_.exchangeamount_;
  _impl_.exchangeamount_ = 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 ::proto::Money* PaymentInfo::unsafe_arena_release_exchangeamount() {
  // @@protoc_insertion_point(field_release:proto.PaymentInfo.exchangeAmount)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Money* temp = _impl_.exchangeamount_;
  _impl_.exchangeamount_ = nullptr;
  return temp;
}
inline ::proto::Money* PaymentInfo::_internal_mutable_exchangeamount() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.exchangeamount_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Money>(GetArenaForAllocation());
    _impl_.exchangeamount_ = p;
  }
  return _impl_.exchangeamount_;
}
inline ::proto::Money* PaymentInfo::mutable_exchangeamount() {
  ::proto::Money* _msg = _internal_mutable_exchangeamount();
  // @@protoc_insertion_point(field_mutable:proto.PaymentInfo.exchangeAmount)
  return _msg;
}
inline void PaymentInfo::set_allocated_exchangeamount(::proto::Money* exchangeamount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.exchangeamount_;
  }
  if (exchangeamount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exchangeamount);
    if (message_arena != submessage_arena) {
      exchangeamount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, exchangeamount, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.exchangeamount_ = exchangeamount;
  // @@protoc_insertion_point(field_set_allocated:proto.PaymentInfo.exchangeAmount)
}

// -------------------------------------------------------------------

// PendingKeyExchange

// optional uint32 sequence = 1;
inline bool PendingKeyExchange::_internal_has_sequence() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_sequence() const {
  return _internal_has_sequence();
}
inline void PendingKeyExchange::clear_sequence() {
  _impl_.sequence_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t PendingKeyExchange::_internal_sequence() const {
  return _impl_.sequence_;
}
inline uint32_t PendingKeyExchange::sequence() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.sequence)
  return _internal_sequence();
}
inline void PendingKeyExchange::_internal_set_sequence(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.sequence_ = value;
}
inline void PendingKeyExchange::set_sequence(uint32_t value) {
  _internal_set_sequence(value);
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.sequence)
}

// optional bytes localBaseKey = 2;
inline bool PendingKeyExchange::_internal_has_localbasekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localbasekey() const {
  return _internal_has_localbasekey();
}
inline void PendingKeyExchange::clear_localbasekey() {
  _impl_.localbasekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PendingKeyExchange::localbasekey() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKey)
  return _internal_localbasekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localbasekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.localbasekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKey)
}
inline std::string* PendingKeyExchange::mutable_localbasekey() {
  std::string* _s = _internal_mutable_localbasekey();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKey)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localbasekey() const {
  return _impl_.localbasekey_.Get();
}
inline void PendingKeyExchange::_internal_set_localbasekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.localbasekey_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localbasekey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.localbasekey_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localbasekey() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKey)
  if (!_internal_has_localbasekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.localbasekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localbasekey_.IsDefault()) {
    _impl_.localbasekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localbasekey(std::string* localbasekey) {
  if (localbasekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.localbasekey_.SetAllocated(localbasekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localbasekey_.IsDefault()) {
    _impl_.localbasekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKey)
}

// optional bytes localBaseKeyPrivate = 3;
inline bool PendingKeyExchange::_internal_has_localbasekeyprivate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localbasekeyprivate() const {
  return _internal_has_localbasekeyprivate();
}
inline void PendingKeyExchange::clear_localbasekeyprivate() {
  _impl_.localbasekeyprivate_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PendingKeyExchange::localbasekeyprivate() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localBaseKeyPrivate)
  return _internal_localbasekeyprivate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localbasekeyprivate(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.localbasekeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localBaseKeyPrivate)
}
inline std::string* PendingKeyExchange::mutable_localbasekeyprivate() {
  std::string* _s = _internal_mutable_localbasekeyprivate();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localBaseKeyPrivate)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localbasekeyprivate() const {
  return _impl_.localbasekeyprivate_.Get();
}
inline void PendingKeyExchange::_internal_set_localbasekeyprivate(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.localbasekeyprivate_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localbasekeyprivate() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.localbasekeyprivate_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localbasekeyprivate() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localBaseKeyPrivate)
  if (!_internal_has_localbasekeyprivate()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.localbasekeyprivate_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localbasekeyprivate_.IsDefault()) {
    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localbasekeyprivate(std::string* localbasekeyprivate) {
  if (localbasekeyprivate != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.localbasekeyprivate_.SetAllocated(localbasekeyprivate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localbasekeyprivate_.IsDefault()) {
    _impl_.localbasekeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localBaseKeyPrivate)
}

// optional bytes localRatchetKey = 4;
inline bool PendingKeyExchange::_internal_has_localratchetkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localratchetkey() const {
  return _internal_has_localratchetkey();
}
inline void PendingKeyExchange::clear_localratchetkey() {
  _impl_.localratchetkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& PendingKeyExchange::localratchetkey() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKey)
  return _internal_localratchetkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localratchetkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.localratchetkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKey)
}
inline std::string* PendingKeyExchange::mutable_localratchetkey() {
  std::string* _s = _internal_mutable_localratchetkey();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKey)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localratchetkey() const {
  return _impl_.localratchetkey_.Get();
}
inline void PendingKeyExchange::_internal_set_localratchetkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.localratchetkey_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localratchetkey() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.localratchetkey_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localratchetkey() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKey)
  if (!_internal_has_localratchetkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.localratchetkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localratchetkey_.IsDefault()) {
    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localratchetkey(std::string* localratchetkey) {
  if (localratchetkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.localratchetkey_.SetAllocated(localratchetkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localratchetkey_.IsDefault()) {
    _impl_.localratchetkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKey)
}

// optional bytes localRatchetKeyPrivate = 5;
inline bool PendingKeyExchange::_internal_has_localratchetkeyprivate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localratchetkeyprivate() const {
  return _internal_has_localratchetkeyprivate();
}
inline void PendingKeyExchange::clear_localratchetkeyprivate() {
  _impl_.localratchetkeyprivate_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& PendingKeyExchange::localratchetkeyprivate() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localRatchetKeyPrivate)
  return _internal_localratchetkeyprivate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localratchetkeyprivate(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.localratchetkeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localRatchetKeyPrivate)
}
inline std::string* PendingKeyExchange::mutable_localratchetkeyprivate() {
  std::string* _s = _internal_mutable_localratchetkeyprivate();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localRatchetKeyPrivate)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localratchetkeyprivate() const {
  return _impl_.localratchetkeyprivate_.Get();
}
inline void PendingKeyExchange::_internal_set_localratchetkeyprivate(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.localratchetkeyprivate_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localratchetkeyprivate() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.localratchetkeyprivate_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localratchetkeyprivate() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localRatchetKeyPrivate)
  if (!_internal_has_localratchetkeyprivate()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.localratchetkeyprivate_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localratchetkeyprivate_.IsDefault()) {
    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localratchetkeyprivate(std::string* localratchetkeyprivate) {
  if (localratchetkeyprivate != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.localratchetkeyprivate_.SetAllocated(localratchetkeyprivate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localratchetkeyprivate_.IsDefault()) {
    _impl_.localratchetkeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localRatchetKeyPrivate)
}

// optional bytes localIdentityKey = 7;
inline bool PendingKeyExchange::_internal_has_localidentitykey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localidentitykey() const {
  return _internal_has_localidentitykey();
}
inline void PendingKeyExchange::clear_localidentitykey() {
  _impl_.localidentitykey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& PendingKeyExchange::localidentitykey() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKey)
  return _internal_localidentitykey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localidentitykey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.localidentitykey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKey)
}
inline std::string* PendingKeyExchange::mutable_localidentitykey() {
  std::string* _s = _internal_mutable_localidentitykey();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKey)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localidentitykey() const {
  return _impl_.localidentitykey_.Get();
}
inline void PendingKeyExchange::_internal_set_localidentitykey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.localidentitykey_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localidentitykey() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.localidentitykey_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localidentitykey() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKey)
  if (!_internal_has_localidentitykey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.localidentitykey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitykey_.IsDefault()) {
    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localidentitykey(std::string* localidentitykey) {
  if (localidentitykey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.localidentitykey_.SetAllocated(localidentitykey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitykey_.IsDefault()) {
    _impl_.localidentitykey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKey)
}

// optional bytes localIdentityKeyPrivate = 8;
inline bool PendingKeyExchange::_internal_has_localidentitykeyprivate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool PendingKeyExchange::has_localidentitykeyprivate() const {
  return _internal_has_localidentitykeyprivate();
}
inline void PendingKeyExchange::clear_localidentitykeyprivate() {
  _impl_.localidentitykeyprivate_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& PendingKeyExchange::localidentitykeyprivate() const {
  // @@protoc_insertion_point(field_get:proto.PendingKeyExchange.localIdentityKeyPrivate)
  return _internal_localidentitykeyprivate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingKeyExchange::set_localidentitykeyprivate(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.localidentitykeyprivate_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingKeyExchange.localIdentityKeyPrivate)
}
inline std::string* PendingKeyExchange::mutable_localidentitykeyprivate() {
  std::string* _s = _internal_mutable_localidentitykeyprivate();
  // @@protoc_insertion_point(field_mutable:proto.PendingKeyExchange.localIdentityKeyPrivate)
  return _s;
}
inline const std::string& PendingKeyExchange::_internal_localidentitykeyprivate() const {
  return _impl_.localidentitykeyprivate_.Get();
}
inline void PendingKeyExchange::_internal_set_localidentitykeyprivate(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.localidentitykeyprivate_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::_internal_mutable_localidentitykeyprivate() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.localidentitykeyprivate_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingKeyExchange::release_localidentitykeyprivate() {
  // @@protoc_insertion_point(field_release:proto.PendingKeyExchange.localIdentityKeyPrivate)
  if (!_internal_has_localidentitykeyprivate()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.localidentitykeyprivate_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitykeyprivate_.IsDefault()) {
    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingKeyExchange::set_allocated_localidentitykeyprivate(std::string* localidentitykeyprivate) {
  if (localidentitykeyprivate != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.localidentitykeyprivate_.SetAllocated(localidentitykeyprivate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitykeyprivate_.IsDefault()) {
    _impl_.localidentitykeyprivate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingKeyExchange.localIdentityKeyPrivate)
}

// -------------------------------------------------------------------

// PendingPreKey

// optional uint32 preKeyId = 1;
inline bool PendingPreKey::_internal_has_prekeyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PendingPreKey::has_prekeyid() const {
  return _internal_has_prekeyid();
}
inline void PendingPreKey::clear_prekeyid() {
  _impl_.prekeyid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t PendingPreKey::_internal_prekeyid() const {
  return _impl_.prekeyid_;
}
inline uint32_t PendingPreKey::prekeyid() const {
  // @@protoc_insertion_point(field_get:proto.PendingPreKey.preKeyId)
  return _internal_prekeyid();
}
inline void PendingPreKey::_internal_set_prekeyid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.prekeyid_ = value;
}
inline void PendingPreKey::set_prekeyid(uint32_t value) {
  _internal_set_prekeyid(value);
  // @@protoc_insertion_point(field_set:proto.PendingPreKey.preKeyId)
}

// optional int32 signedPreKeyId = 3;
inline bool PendingPreKey::_internal_has_signedprekeyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PendingPreKey::has_signedprekeyid() const {
  return _internal_has_signedprekeyid();
}
inline void PendingPreKey::clear_signedprekeyid() {
  _impl_.signedprekeyid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t PendingPreKey::_internal_signedprekeyid() const {
  return _impl_.signedprekeyid_;
}
inline int32_t PendingPreKey::signedprekeyid() const {
  // @@protoc_insertion_point(field_get:proto.PendingPreKey.signedPreKeyId)
  return _internal_signedprekeyid();
}
inline void PendingPreKey::_internal_set_signedprekeyid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.signedprekeyid_ = value;
}
inline void PendingPreKey::set_signedprekeyid(int32_t value) {
  _internal_set_signedprekeyid(value);
  // @@protoc_insertion_point(field_set:proto.PendingPreKey.signedPreKeyId)
}

// optional bytes baseKey = 2;
inline bool PendingPreKey::_internal_has_basekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PendingPreKey::has_basekey() const {
  return _internal_has_basekey();
}
inline void PendingPreKey::clear_basekey() {
  _impl_.basekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PendingPreKey::basekey() const {
  // @@protoc_insertion_point(field_get:proto.PendingPreKey.baseKey)
  return _internal_basekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PendingPreKey::set_basekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.basekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PendingPreKey.baseKey)
}
inline std::string* PendingPreKey::mutable_basekey() {
  std::string* _s = _internal_mutable_basekey();
  // @@protoc_insertion_point(field_mutable:proto.PendingPreKey.baseKey)
  return _s;
}
inline const std::string& PendingPreKey::_internal_basekey() const {
  return _impl_.basekey_.Get();
}
inline void PendingPreKey::_internal_set_basekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.basekey_.Set(value, GetArenaForAllocation());
}
inline std::string* PendingPreKey::_internal_mutable_basekey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.basekey_.Mutable(GetArenaForAllocation());
}
inline std::string* PendingPreKey::release_basekey() {
  // @@protoc_insertion_point(field_release:proto.PendingPreKey.baseKey)
  if (!_internal_has_basekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.basekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.basekey_.IsDefault()) {
    _impl_.basekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PendingPreKey::set_allocated_basekey(std::string* basekey) {
  if (basekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.basekey_.SetAllocated(basekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.basekey_.IsDefault()) {
    _impl_.basekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PendingPreKey.baseKey)
}

// -------------------------------------------------------------------

// PhotoChange

// optional bytes oldPhoto = 1;
inline bool PhotoChange::_internal_has_oldphoto() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PhotoChange::has_oldphoto() const {
  return _internal_has_oldphoto();
}
inline void PhotoChange::clear_oldphoto() {
  _impl_.oldphoto_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PhotoChange::oldphoto() const {
  // @@protoc_insertion_point(field_get:proto.PhotoChange.oldPhoto)
  return _internal_oldphoto();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PhotoChange::set_oldphoto(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.oldphoto_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PhotoChange.oldPhoto)
}
inline std::string* PhotoChange::mutable_oldphoto() {
  std::string* _s = _internal_mutable_oldphoto();
  // @@protoc_insertion_point(field_mutable:proto.PhotoChange.oldPhoto)
  return _s;
}
inline const std::string& PhotoChange::_internal_oldphoto() const {
  return _impl_.oldphoto_.Get();
}
inline void PhotoChange::_internal_set_oldphoto(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.oldphoto_.Set(value, GetArenaForAllocation());
}
inline std::string* PhotoChange::_internal_mutable_oldphoto() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.oldphoto_.Mutable(GetArenaForAllocation());
}
inline std::string* PhotoChange::release_oldphoto() {
  // @@protoc_insertion_point(field_release:proto.PhotoChange.oldPhoto)
  if (!_internal_has_oldphoto()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.oldphoto_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.oldphoto_.IsDefault()) {
    _impl_.oldphoto_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PhotoChange::set_allocated_oldphoto(std::string* oldphoto) {
  if (oldphoto != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.oldphoto_.SetAllocated(oldphoto, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.oldphoto_.IsDefault()) {
    _impl_.oldphoto_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.oldPhoto)
}

// optional bytes newPhoto = 2;
inline bool PhotoChange::_internal_has_newphoto() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PhotoChange::has_newphoto() const {
  return _internal_has_newphoto();
}
inline void PhotoChange::clear_newphoto() {
  _impl_.newphoto_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PhotoChange::newphoto() const {
  // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhoto)
  return _internal_newphoto();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PhotoChange::set_newphoto(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.newphoto_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhoto)
}
inline std::string* PhotoChange::mutable_newphoto() {
  std::string* _s = _internal_mutable_newphoto();
  // @@protoc_insertion_point(field_mutable:proto.PhotoChange.newPhoto)
  return _s;
}
inline const std::string& PhotoChange::_internal_newphoto() const {
  return _impl_.newphoto_.Get();
}
inline void PhotoChange::_internal_set_newphoto(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.newphoto_.Set(value, GetArenaForAllocation());
}
inline std::string* PhotoChange::_internal_mutable_newphoto() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.newphoto_.Mutable(GetArenaForAllocation());
}
inline std::string* PhotoChange::release_newphoto() {
  // @@protoc_insertion_point(field_release:proto.PhotoChange.newPhoto)
  if (!_internal_has_newphoto()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.newphoto_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.newphoto_.IsDefault()) {
    _impl_.newphoto_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PhotoChange::set_allocated_newphoto(std::string* newphoto) {
  if (newphoto != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.newphoto_.SetAllocated(newphoto, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.newphoto_.IsDefault()) {
    _impl_.newphoto_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PhotoChange.newPhoto)
}

// optional uint32 newPhotoId = 3;
inline bool PhotoChange::_internal_has_newphotoid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PhotoChange::has_newphotoid() const {
  return _internal_has_newphotoid();
}
inline void PhotoChange::clear_newphotoid() {
  _impl_.newphotoid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PhotoChange::_internal_newphotoid() const {
  return _impl_.newphotoid_;
}
inline uint32_t PhotoChange::newphotoid() const {
  // @@protoc_insertion_point(field_get:proto.PhotoChange.newPhotoId)
  return _internal_newphotoid();
}
inline void PhotoChange::_internal_set_newphotoid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.newphotoid_ = value;
}
inline void PhotoChange::set_newphotoid(uint32_t value) {
  _internal_set_newphotoid(value);
  // @@protoc_insertion_point(field_set:proto.PhotoChange.newPhotoId)
}

// -------------------------------------------------------------------

// Point

// optional int32 xDeprecated = 1;
inline bool Point::_internal_has_xdeprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Point::has_xdeprecated() const {
  return _internal_has_xdeprecated();
}
inline void Point::clear_xdeprecated() {
  _impl_.xdeprecated_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t Point::_internal_xdeprecated() const {
  return _impl_.xdeprecated_;
}
inline int32_t Point::xdeprecated() const {
  // @@protoc_insertion_point(field_get:proto.Point.xDeprecated)
  return _internal_xdeprecated();
}
inline void Point::_internal_set_xdeprecated(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.xdeprecated_ = value;
}
inline void Point::set_xdeprecated(int32_t value) {
  _internal_set_xdeprecated(value);
  // @@protoc_insertion_point(field_set:proto.Point.xDeprecated)
}

// optional int32 yDeprecated = 2;
inline bool Point::_internal_has_ydeprecated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Point::has_ydeprecated() const {
  return _internal_has_ydeprecated();
}
inline void Point::clear_ydeprecated() {
  _impl_.ydeprecated_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t Point::_internal_ydeprecated() const {
  return _impl_.ydeprecated_;
}
inline int32_t Point::ydeprecated() const {
  // @@protoc_insertion_point(field_get:proto.Point.yDeprecated)
  return _internal_ydeprecated();
}
inline void Point::_internal_set_ydeprecated(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ydeprecated_ = value;
}
inline void Point::set_ydeprecated(int32_t value) {
  _internal_set_ydeprecated(value);
  // @@protoc_insertion_point(field_set:proto.Point.yDeprecated)
}

// optional double x = 3;
inline bool Point::_internal_has_x() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Point::has_x() const {
  return _internal_has_x();
}
inline void Point::clear_x() {
  _impl_.x_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline double Point::_internal_x() const {
  return _impl_.x_;
}
inline double Point::x() const {
  // @@protoc_insertion_point(field_get:proto.Point.x)
  return _internal_x();
}
inline void Point::_internal_set_x(double value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.x_ = value;
}
inline void Point::set_x(double value) {
  _internal_set_x(value);
  // @@protoc_insertion_point(field_set:proto.Point.x)
}

// optional double y = 4;
inline bool Point::_internal_has_y() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Point::has_y() const {
  return _internal_has_y();
}
inline void Point::clear_y() {
  _impl_.y_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline double Point::_internal_y() const {
  return _impl_.y_;
}
inline double Point::y() const {
  // @@protoc_insertion_point(field_get:proto.Point.y)
  return _internal_y();
}
inline void Point::_internal_set_y(double value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.y_ = value;
}
inline void Point::set_y(double value) {
  _internal_set_y(value);
  // @@protoc_insertion_point(field_set:proto.Point.y)
}

// -------------------------------------------------------------------

// PollAdditionalMetadata

// optional bool pollInvalidated = 1;
inline bool PollAdditionalMetadata::_internal_has_pollinvalidated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PollAdditionalMetadata::has_pollinvalidated() const {
  return _internal_has_pollinvalidated();
}
inline void PollAdditionalMetadata::clear_pollinvalidated() {
  _impl_.pollinvalidated_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool PollAdditionalMetadata::_internal_pollinvalidated() const {
  return _impl_.pollinvalidated_;
}
inline bool PollAdditionalMetadata::pollinvalidated() const {
  // @@protoc_insertion_point(field_get:proto.PollAdditionalMetadata.pollInvalidated)
  return _internal_pollinvalidated();
}
inline void PollAdditionalMetadata::_internal_set_pollinvalidated(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pollinvalidated_ = value;
}
inline void PollAdditionalMetadata::set_pollinvalidated(bool value) {
  _internal_set_pollinvalidated(value);
  // @@protoc_insertion_point(field_set:proto.PollAdditionalMetadata.pollInvalidated)
}

// -------------------------------------------------------------------

// PollEncValue

// optional bytes encPayload = 1;
inline bool PollEncValue::_internal_has_encpayload() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PollEncValue::has_encpayload() const {
  return _internal_has_encpayload();
}
inline void PollEncValue::clear_encpayload() {
  _impl_.encpayload_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PollEncValue::encpayload() const {
  // @@protoc_insertion_point(field_get:proto.PollEncValue.encPayload)
  return _internal_encpayload();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PollEncValue::set_encpayload(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.encpayload_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PollEncValue.encPayload)
}
inline std::string* PollEncValue::mutable_encpayload() {
  std::string* _s = _internal_mutable_encpayload();
  // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encPayload)
  return _s;
}
inline const std::string& PollEncValue::_internal_encpayload() const {
  return _impl_.encpayload_.Get();
}
inline void PollEncValue::_internal_set_encpayload(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.encpayload_.Set(value, GetArenaForAllocation());
}
inline std::string* PollEncValue::_internal_mutable_encpayload() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.encpayload_.Mutable(GetArenaForAllocation());
}
inline std::string* PollEncValue::release_encpayload() {
  // @@protoc_insertion_point(field_release:proto.PollEncValue.encPayload)
  if (!_internal_has_encpayload()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.encpayload_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encpayload_.IsDefault()) {
    _impl_.encpayload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PollEncValue::set_allocated_encpayload(std::string* encpayload) {
  if (encpayload != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.encpayload_.SetAllocated(encpayload, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encpayload_.IsDefault()) {
    _impl_.encpayload_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encPayload)
}

// optional bytes encIv = 2;
inline bool PollEncValue::_internal_has_enciv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PollEncValue::has_enciv() const {
  return _internal_has_enciv();
}
inline void PollEncValue::clear_enciv() {
  _impl_.enciv_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PollEncValue::enciv() const {
  // @@protoc_insertion_point(field_get:proto.PollEncValue.encIv)
  return _internal_enciv();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PollEncValue::set_enciv(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.enciv_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.PollEncValue.encIv)
}
inline std::string* PollEncValue::mutable_enciv() {
  std::string* _s = _internal_mutable_enciv();
  // @@protoc_insertion_point(field_mutable:proto.PollEncValue.encIv)
  return _s;
}
inline const std::string& PollEncValue::_internal_enciv() const {
  return _impl_.enciv_.Get();
}
inline void PollEncValue::_internal_set_enciv(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.enciv_.Set(value, GetArenaForAllocation());
}
inline std::string* PollEncValue::_internal_mutable_enciv() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.enciv_.Mutable(GetArenaForAllocation());
}
inline std::string* PollEncValue::release_enciv() {
  // @@protoc_insertion_point(field_release:proto.PollEncValue.encIv)
  if (!_internal_has_enciv()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.enciv_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enciv_.IsDefault()) {
    _impl_.enciv_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void PollEncValue::set_allocated_enciv(std::string* enciv) {
  if (enciv != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.enciv_.SetAllocated(enciv, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.enciv_.IsDefault()) {
    _impl_.enciv_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.PollEncValue.encIv)
}

// -------------------------------------------------------------------

// PollUpdate

// optional .proto.MessageKey pollUpdateMessageKey = 1;
inline bool PollUpdate::_internal_has_pollupdatemessagekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pollupdatemessagekey_ != nullptr);
  return value;
}
inline bool PollUpdate::has_pollupdatemessagekey() const {
  return _internal_has_pollupdatemessagekey();
}
inline void PollUpdate::clear_pollupdatemessagekey() {
  if (_impl_.pollupdatemessagekey_ != nullptr) _impl_.pollupdatemessagekey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& PollUpdate::_internal_pollupdatemessagekey() const {
  const ::proto::MessageKey* p = _impl_.pollupdatemessagekey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& PollUpdate::pollupdatemessagekey() const {
  // @@protoc_insertion_point(field_get:proto.PollUpdate.pollUpdateMessageKey)
  return _internal_pollupdatemessagekey();
}
inline void PollUpdate::unsafe_arena_set_allocated_pollupdatemessagekey(
    ::proto::MessageKey* pollupdatemessagekey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pollupdatemessagekey_);
  }
  _impl_.pollupdatemessagekey_ = pollupdatemessagekey;
  if (pollupdatemessagekey) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.pollUpdateMessageKey)
}
inline ::proto::MessageKey* PollUpdate::release_pollupdatemessagekey() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_;
  _impl_.pollupdatemessagekey_ = 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 ::proto::MessageKey* PollUpdate::unsafe_arena_release_pollupdatemessagekey() {
  // @@protoc_insertion_point(field_release:proto.PollUpdate.pollUpdateMessageKey)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.pollupdatemessagekey_;
  _impl_.pollupdatemessagekey_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* PollUpdate::_internal_mutable_pollupdatemessagekey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.pollupdatemessagekey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.pollupdatemessagekey_ = p;
  }
  return _impl_.pollupdatemessagekey_;
}
inline ::proto::MessageKey* PollUpdate::mutable_pollupdatemessagekey() {
  ::proto::MessageKey* _msg = _internal_mutable_pollupdatemessagekey();
  // @@protoc_insertion_point(field_mutable:proto.PollUpdate.pollUpdateMessageKey)
  return _msg;
}
inline void PollUpdate::set_allocated_pollupdatemessagekey(::proto::MessageKey* pollupdatemessagekey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pollupdatemessagekey_;
  }
  if (pollupdatemessagekey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pollupdatemessagekey);
    if (message_arena != submessage_arena) {
      pollupdatemessagekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pollupdatemessagekey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pollupdatemessagekey_ = pollupdatemessagekey;
  // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.pollUpdateMessageKey)
}

// optional .proto.Message.PollVoteMessage vote = 2;
inline bool PollUpdate::_internal_has_vote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.vote_ != nullptr);
  return value;
}
inline bool PollUpdate::has_vote() const {
  return _internal_has_vote();
}
inline void PollUpdate::clear_vote() {
  if (_impl_.vote_ != nullptr) _impl_.vote_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_PollVoteMessage& PollUpdate::_internal_vote() const {
  const ::proto::Message_PollVoteMessage* p = _impl_.vote_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_PollVoteMessage&>(
      ::proto::_Message_PollVoteMessage_default_instance_);
}
inline const ::proto::Message_PollVoteMessage& PollUpdate::vote() const {
  // @@protoc_insertion_point(field_get:proto.PollUpdate.vote)
  return _internal_vote();
}
inline void PollUpdate::unsafe_arena_set_allocated_vote(
    ::proto::Message_PollVoteMessage* vote) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vote_);
  }
  _impl_.vote_ = vote;
  if (vote) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.PollUpdate.vote)
}
inline ::proto::Message_PollVoteMessage* PollUpdate::release_vote() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_PollVoteMessage* temp = _impl_.vote_;
  _impl_.vote_ = 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 ::proto::Message_PollVoteMessage* PollUpdate::unsafe_arena_release_vote() {
  // @@protoc_insertion_point(field_release:proto.PollUpdate.vote)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_PollVoteMessage* temp = _impl_.vote_;
  _impl_.vote_ = nullptr;
  return temp;
}
inline ::proto::Message_PollVoteMessage* PollUpdate::_internal_mutable_vote() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.vote_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_PollVoteMessage>(GetArenaForAllocation());
    _impl_.vote_ = p;
  }
  return _impl_.vote_;
}
inline ::proto::Message_PollVoteMessage* PollUpdate::mutable_vote() {
  ::proto::Message_PollVoteMessage* _msg = _internal_mutable_vote();
  // @@protoc_insertion_point(field_mutable:proto.PollUpdate.vote)
  return _msg;
}
inline void PollUpdate::set_allocated_vote(::proto::Message_PollVoteMessage* vote) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.vote_;
  }
  if (vote) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(vote);
    if (message_arena != submessage_arena) {
      vote = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, vote, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.vote_ = vote;
  // @@protoc_insertion_point(field_set_allocated:proto.PollUpdate.vote)
}

// optional int64 senderTimestampMs = 3;
inline bool PollUpdate::_internal_has_sendertimestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PollUpdate::has_sendertimestampms() const {
  return _internal_has_sendertimestampms();
}
inline void PollUpdate::clear_sendertimestampms() {
  _impl_.sendertimestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t PollUpdate::_internal_sendertimestampms() const {
  return _impl_.sendertimestampms_;
}
inline int64_t PollUpdate::sendertimestampms() const {
  // @@protoc_insertion_point(field_get:proto.PollUpdate.senderTimestampMs)
  return _internal_sendertimestampms();
}
inline void PollUpdate::_internal_set_sendertimestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.sendertimestampms_ = value;
}
inline void PollUpdate::set_sendertimestampms(int64_t value) {
  _internal_set_sendertimestampms(value);
  // @@protoc_insertion_point(field_set:proto.PollUpdate.senderTimestampMs)
}

// -------------------------------------------------------------------

// PreKeyRecordStructure

// optional uint32 id = 1;
inline bool PreKeyRecordStructure::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool PreKeyRecordStructure::has_id() const {
  return _internal_has_id();
}
inline void PreKeyRecordStructure::clear_id() {
  _impl_.id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t PreKeyRecordStructure::_internal_id() const {
  return _impl_.id_;
}
inline uint32_t PreKeyRecordStructure::id() const {
  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.id)
  return _internal_id();
}
inline void PreKeyRecordStructure::_internal_set_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.id_ = value;
}
inline void PreKeyRecordStructure::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:proto.PreKeyRecordStructure.id)
}

// optional bytes publicKey = 2;
inline bool PreKeyRecordStructure::_internal_has_publickey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool PreKeyRecordStructure::has_publickey() const {
  return _internal_has_publickey();
}
inline void PreKeyRecordStructure::clear_publickey() {
  _impl_.publickey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& PreKeyRecordStructure::publickey() const {
  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.publicKey)
  return _internal_publickey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PreKeyRecordStructure::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:proto.PreKeyRecordStructure.publicKey)
}
inline std::string* PreKeyRecordStructure::mutable_publickey() {
  std::string* _s = _internal_mutable_publickey();
  // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.publicKey)
  return _s;
}
inline const std::string& PreKeyRecordStructure::_internal_publickey() const {
  return _impl_.publickey_.Get();
}
inline void PreKeyRecordStructure::_internal_set_publickey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.publickey_.Set(value, GetArenaForAllocation());
}
inline std::string* PreKeyRecordStructure::_internal_mutable_publickey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.publickey_.Mutable(GetArenaForAllocation());
}
inline std::string* PreKeyRecordStructure::release_publickey() {
  // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.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 PreKeyRecordStructure::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:proto.PreKeyRecordStructure.publicKey)
}

// optional bytes privateKey = 3;
inline bool PreKeyRecordStructure::_internal_has_privatekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool PreKeyRecordStructure::has_privatekey() const {
  return _internal_has_privatekey();
}
inline void PreKeyRecordStructure::clear_privatekey() {
  _impl_.privatekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& PreKeyRecordStructure::privatekey() const {
  // @@protoc_insertion_point(field_get:proto.PreKeyRecordStructure.privateKey)
  return _internal_privatekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void PreKeyRecordStructure::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:proto.PreKeyRecordStructure.privateKey)
}
inline std::string* PreKeyRecordStructure::mutable_privatekey() {
  std::string* _s = _internal_mutable_privatekey();
  // @@protoc_insertion_point(field_mutable:proto.PreKeyRecordStructure.privateKey)
  return _s;
}
inline const std::string& PreKeyRecordStructure::_internal_privatekey() const {
  return _impl_.privatekey_.Get();
}
inline void PreKeyRecordStructure::_internal_set_privatekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.privatekey_.Set(value, GetArenaForAllocation());
}
inline std::string* PreKeyRecordStructure::_internal_mutable_privatekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
}
inline std::string* PreKeyRecordStructure::release_privatekey() {
  // @@protoc_insertion_point(field_release:proto.PreKeyRecordStructure.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 PreKeyRecordStructure::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:proto.PreKeyRecordStructure.privateKey)
}

// -------------------------------------------------------------------

// Pushname

// optional string id = 1;
inline bool Pushname::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Pushname::has_id() const {
  return _internal_has_id();
}
inline void Pushname::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Pushname::id() const {
  // @@protoc_insertion_point(field_get:proto.Pushname.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Pushname::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Pushname.id)
}
inline std::string* Pushname::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.Pushname.id)
  return _s;
}
inline const std::string& Pushname::_internal_id() const {
  return _impl_.id_.Get();
}
inline void Pushname::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* Pushname::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* Pushname::release_id() {
  // @@protoc_insertion_point(field_release:proto.Pushname.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Pushname::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Pushname.id)
}

// optional string pushname = 2;
inline bool Pushname::_internal_has_pushname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Pushname::has_pushname() const {
  return _internal_has_pushname();
}
inline void Pushname::clear_pushname() {
  _impl_.pushname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Pushname::pushname() const {
  // @@protoc_insertion_point(field_get:proto.Pushname.pushname)
  return _internal_pushname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Pushname::set_pushname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Pushname.pushname)
}
inline std::string* Pushname::mutable_pushname() {
  std::string* _s = _internal_mutable_pushname();
  // @@protoc_insertion_point(field_mutable:proto.Pushname.pushname)
  return _s;
}
inline const std::string& Pushname::_internal_pushname() const {
  return _impl_.pushname_.Get();
}
inline void Pushname::_internal_set_pushname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pushname_.Set(value, GetArenaForAllocation());
}
inline std::string* Pushname::_internal_mutable_pushname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.pushname_.Mutable(GetArenaForAllocation());
}
inline std::string* Pushname::release_pushname() {
  // @@protoc_insertion_point(field_release:proto.Pushname.pushname)
  if (!_internal_has_pushname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.pushname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Pushname::set_allocated_pushname(std::string* pushname) {
  if (pushname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Pushname.pushname)
}

// -------------------------------------------------------------------

// Reaction

// optional .proto.MessageKey key = 1;
inline bool Reaction::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool Reaction::has_key() const {
  return _internal_has_key();
}
inline void Reaction::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::MessageKey& Reaction::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& Reaction::key() const {
  // @@protoc_insertion_point(field_get:proto.Reaction.key)
  return _internal_key();
}
inline void Reaction::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.Reaction.key)
}
inline ::proto::MessageKey* Reaction::release_key() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* Reaction::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.Reaction.key)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* Reaction::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* Reaction::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.Reaction.key)
  return _msg;
}
inline void Reaction::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.Reaction.key)
}

// optional string text = 2;
inline bool Reaction::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Reaction::has_text() const {
  return _internal_has_text();
}
inline void Reaction::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Reaction::text() const {
  // @@protoc_insertion_point(field_get:proto.Reaction.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Reaction::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Reaction.text)
}
inline std::string* Reaction::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:proto.Reaction.text)
  return _s;
}
inline const std::string& Reaction::_internal_text() const {
  return _impl_.text_.Get();
}
inline void Reaction::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* Reaction::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* Reaction::release_text() {
  // @@protoc_insertion_point(field_release:proto.Reaction.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 Reaction::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.Reaction.text)
}

// optional string groupingKey = 3;
inline bool Reaction::_internal_has_groupingkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Reaction::has_groupingkey() const {
  return _internal_has_groupingkey();
}
inline void Reaction::clear_groupingkey() {
  _impl_.groupingkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Reaction::groupingkey() const {
  // @@protoc_insertion_point(field_get:proto.Reaction.groupingKey)
  return _internal_groupingkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Reaction::set_groupingkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.groupingkey_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.Reaction.groupingKey)
}
inline std::string* Reaction::mutable_groupingkey() {
  std::string* _s = _internal_mutable_groupingkey();
  // @@protoc_insertion_point(field_mutable:proto.Reaction.groupingKey)
  return _s;
}
inline const std::string& Reaction::_internal_groupingkey() const {
  return _impl_.groupingkey_.Get();
}
inline void Reaction::_internal_set_groupingkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.groupingkey_.Set(value, GetArenaForAllocation());
}
inline std::string* Reaction::_internal_mutable_groupingkey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.groupingkey_.Mutable(GetArenaForAllocation());
}
inline std::string* Reaction::release_groupingkey() {
  // @@protoc_insertion_point(field_release:proto.Reaction.groupingKey)
  if (!_internal_has_groupingkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.groupingkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupingkey_.IsDefault()) {
    _impl_.groupingkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void Reaction::set_allocated_groupingkey(std::string* groupingkey) {
  if (groupingkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.groupingkey_.SetAllocated(groupingkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.groupingkey_.IsDefault()) {
    _impl_.groupingkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.Reaction.groupingKey)
}

// optional int64 senderTimestampMs = 4;
inline bool Reaction::_internal_has_sendertimestampms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Reaction::has_sendertimestampms() const {
  return _internal_has_sendertimestampms();
}
inline void Reaction::clear_sendertimestampms() {
  _impl_.sendertimestampms_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t Reaction::_internal_sendertimestampms() const {
  return _impl_.sendertimestampms_;
}
inline int64_t Reaction::sendertimestampms() const {
  // @@protoc_insertion_point(field_get:proto.Reaction.senderTimestampMs)
  return _internal_sendertimestampms();
}
inline void Reaction::_internal_set_sendertimestampms(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.sendertimestampms_ = value;
}
inline void Reaction::set_sendertimestampms(int64_t value) {
  _internal_set_sendertimestampms(value);
  // @@protoc_insertion_point(field_set:proto.Reaction.senderTimestampMs)
}

// optional bool unread = 5;
inline bool Reaction::_internal_has_unread() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Reaction::has_unread() const {
  return _internal_has_unread();
}
inline void Reaction::clear_unread() {
  _impl_.unread_ = false;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline bool Reaction::_internal_unread() const {
  return _impl_.unread_;
}
inline bool Reaction::unread() const {
  // @@protoc_insertion_point(field_get:proto.Reaction.unread)
  return _internal_unread();
}
inline void Reaction::_internal_set_unread(bool value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.unread_ = value;
}
inline void Reaction::set_unread(bool value) {
  _internal_set_unread(value);
  // @@protoc_insertion_point(field_set:proto.Reaction.unread)
}

// -------------------------------------------------------------------

// RecentEmojiWeight

// optional string emoji = 1;
inline bool RecentEmojiWeight::_internal_has_emoji() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool RecentEmojiWeight::has_emoji() const {
  return _internal_has_emoji();
}
inline void RecentEmojiWeight::clear_emoji() {
  _impl_.emoji_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& RecentEmojiWeight::emoji() const {
  // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.emoji)
  return _internal_emoji();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RecentEmojiWeight::set_emoji(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.emoji_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.emoji)
}
inline std::string* RecentEmojiWeight::mutable_emoji() {
  std::string* _s = _internal_mutable_emoji();
  // @@protoc_insertion_point(field_mutable:proto.RecentEmojiWeight.emoji)
  return _s;
}
inline const std::string& RecentEmojiWeight::_internal_emoji() const {
  return _impl_.emoji_.Get();
}
inline void RecentEmojiWeight::_internal_set_emoji(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.emoji_.Set(value, GetArenaForAllocation());
}
inline std::string* RecentEmojiWeight::_internal_mutable_emoji() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.emoji_.Mutable(GetArenaForAllocation());
}
inline std::string* RecentEmojiWeight::release_emoji() {
  // @@protoc_insertion_point(field_release:proto.RecentEmojiWeight.emoji)
  if (!_internal_has_emoji()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 RecentEmojiWeight::set_allocated_emoji(std::string* emoji) {
  if (emoji != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.RecentEmojiWeight.emoji)
}

// optional float weight = 2;
inline bool RecentEmojiWeight::_internal_has_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool RecentEmojiWeight::has_weight() const {
  return _internal_has_weight();
}
inline void RecentEmojiWeight::clear_weight() {
  _impl_.weight_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline float RecentEmojiWeight::_internal_weight() const {
  return _impl_.weight_;
}
inline float RecentEmojiWeight::weight() const {
  // @@protoc_insertion_point(field_get:proto.RecentEmojiWeight.weight)
  return _internal_weight();
}
inline void RecentEmojiWeight::_internal_set_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.weight_ = value;
}
inline void RecentEmojiWeight::set_weight(float value) {
  _internal_set_weight(value);
  // @@protoc_insertion_point(field_set:proto.RecentEmojiWeight.weight)
}

// -------------------------------------------------------------------

// RecordStructure

// optional .proto.SessionStructure currentSession = 1;
inline bool RecordStructure::_internal_has_currentsession() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.currentsession_ != nullptr);
  return value;
}
inline bool RecordStructure::has_currentsession() const {
  return _internal_has_currentsession();
}
inline void RecordStructure::clear_currentsession() {
  if (_impl_.currentsession_ != nullptr) _impl_.currentsession_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SessionStructure& RecordStructure::_internal_currentsession() const {
  const ::proto::SessionStructure* p = _impl_.currentsession_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SessionStructure&>(
      ::proto::_SessionStructure_default_instance_);
}
inline const ::proto::SessionStructure& RecordStructure::currentsession() const {
  // @@protoc_insertion_point(field_get:proto.RecordStructure.currentSession)
  return _internal_currentsession();
}
inline void RecordStructure::unsafe_arena_set_allocated_currentsession(
    ::proto::SessionStructure* currentsession) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.currentsession_);
  }
  _impl_.currentsession_ = currentsession;
  if (currentsession) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.RecordStructure.currentSession)
}
inline ::proto::SessionStructure* RecordStructure::release_currentsession() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SessionStructure* temp = _impl_.currentsession_;
  _impl_.currentsession_ = 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 ::proto::SessionStructure* RecordStructure::unsafe_arena_release_currentsession() {
  // @@protoc_insertion_point(field_release:proto.RecordStructure.currentSession)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SessionStructure* temp = _impl_.currentsession_;
  _impl_.currentsession_ = nullptr;
  return temp;
}
inline ::proto::SessionStructure* RecordStructure::_internal_mutable_currentsession() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.currentsession_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SessionStructure>(GetArenaForAllocation());
    _impl_.currentsession_ = p;
  }
  return _impl_.currentsession_;
}
inline ::proto::SessionStructure* RecordStructure::mutable_currentsession() {
  ::proto::SessionStructure* _msg = _internal_mutable_currentsession();
  // @@protoc_insertion_point(field_mutable:proto.RecordStructure.currentSession)
  return _msg;
}
inline void RecordStructure::set_allocated_currentsession(::proto::SessionStructure* currentsession) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.currentsession_;
  }
  if (currentsession) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(currentsession);
    if (message_arena != submessage_arena) {
      currentsession = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, currentsession, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.currentsession_ = currentsession;
  // @@protoc_insertion_point(field_set_allocated:proto.RecordStructure.currentSession)
}

// repeated .proto.SessionStructure previousSessions = 2;
inline int RecordStructure::_internal_previoussessions_size() const {
  return _impl_.previoussessions_.size();
}
inline int RecordStructure::previoussessions_size() const {
  return _internal_previoussessions_size();
}
inline void RecordStructure::clear_previoussessions() {
  _impl_.previoussessions_.Clear();
}
inline ::proto::SessionStructure* RecordStructure::mutable_previoussessions(int index) {
  // @@protoc_insertion_point(field_mutable:proto.RecordStructure.previousSessions)
  return _impl_.previoussessions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >*
RecordStructure::mutable_previoussessions() {
  // @@protoc_insertion_point(field_mutable_list:proto.RecordStructure.previousSessions)
  return &_impl_.previoussessions_;
}
inline const ::proto::SessionStructure& RecordStructure::_internal_previoussessions(int index) const {
  return _impl_.previoussessions_.Get(index);
}
inline const ::proto::SessionStructure& RecordStructure::previoussessions(int index) const {
  // @@protoc_insertion_point(field_get:proto.RecordStructure.previousSessions)
  return _internal_previoussessions(index);
}
inline ::proto::SessionStructure* RecordStructure::_internal_add_previoussessions() {
  return _impl_.previoussessions_.Add();
}
inline ::proto::SessionStructure* RecordStructure::add_previoussessions() {
  ::proto::SessionStructure* _add = _internal_add_previoussessions();
  // @@protoc_insertion_point(field_add:proto.RecordStructure.previousSessions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SessionStructure >&
RecordStructure::previoussessions() const {
  // @@protoc_insertion_point(field_list:proto.RecordStructure.previousSessions)
  return _impl_.previoussessions_;
}

// -------------------------------------------------------------------

// SenderChainKey

// optional uint32 iteration = 1;
inline bool SenderChainKey::_internal_has_iteration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SenderChainKey::has_iteration() const {
  return _internal_has_iteration();
}
inline void SenderChainKey::clear_iteration() {
  _impl_.iteration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SenderChainKey::_internal_iteration() const {
  return _impl_.iteration_;
}
inline uint32_t SenderChainKey::iteration() const {
  // @@protoc_insertion_point(field_get:proto.SenderChainKey.iteration)
  return _internal_iteration();
}
inline void SenderChainKey::_internal_set_iteration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.iteration_ = value;
}
inline void SenderChainKey::set_iteration(uint32_t value) {
  _internal_set_iteration(value);
  // @@protoc_insertion_point(field_set:proto.SenderChainKey.iteration)
}

// optional bytes seed = 2;
inline bool SenderChainKey::_internal_has_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SenderChainKey::has_seed() const {
  return _internal_has_seed();
}
inline void SenderChainKey::clear_seed() {
  _impl_.seed_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SenderChainKey::seed() const {
  // @@protoc_insertion_point(field_get:proto.SenderChainKey.seed)
  return _internal_seed();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SenderChainKey::set_seed(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.seed_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SenderChainKey.seed)
}
inline std::string* SenderChainKey::mutable_seed() {
  std::string* _s = _internal_mutable_seed();
  // @@protoc_insertion_point(field_mutable:proto.SenderChainKey.seed)
  return _s;
}
inline const std::string& SenderChainKey::_internal_seed() const {
  return _impl_.seed_.Get();
}
inline void SenderChainKey::_internal_set_seed(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.seed_.Set(value, GetArenaForAllocation());
}
inline std::string* SenderChainKey::_internal_mutable_seed() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.seed_.Mutable(GetArenaForAllocation());
}
inline std::string* SenderChainKey::release_seed() {
  // @@protoc_insertion_point(field_release:proto.SenderChainKey.seed)
  if (!_internal_has_seed()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.seed_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.seed_.IsDefault()) {
    _impl_.seed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SenderChainKey::set_allocated_seed(std::string* seed) {
  if (seed != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.seed_.SetAllocated(seed, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.seed_.IsDefault()) {
    _impl_.seed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SenderChainKey.seed)
}

// -------------------------------------------------------------------

// SenderKeyRecordStructure

// repeated .proto.SenderKeyStateStructure senderKeyStates = 1;
inline int SenderKeyRecordStructure::_internal_senderkeystates_size() const {
  return _impl_.senderkeystates_.size();
}
inline int SenderKeyRecordStructure::senderkeystates_size() const {
  return _internal_senderkeystates_size();
}
inline void SenderKeyRecordStructure::clear_senderkeystates() {
  _impl_.senderkeystates_.Clear();
}
inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::mutable_senderkeystates(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SenderKeyRecordStructure.senderKeyStates)
  return _impl_.senderkeystates_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >*
SenderKeyRecordStructure::mutable_senderkeystates() {
  // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyRecordStructure.senderKeyStates)
  return &_impl_.senderkeystates_;
}
inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::_internal_senderkeystates(int index) const {
  return _impl_.senderkeystates_.Get(index);
}
inline const ::proto::SenderKeyStateStructure& SenderKeyRecordStructure::senderkeystates(int index) const {
  // @@protoc_insertion_point(field_get:proto.SenderKeyRecordStructure.senderKeyStates)
  return _internal_senderkeystates(index);
}
inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::_internal_add_senderkeystates() {
  return _impl_.senderkeystates_.Add();
}
inline ::proto::SenderKeyStateStructure* SenderKeyRecordStructure::add_senderkeystates() {
  ::proto::SenderKeyStateStructure* _add = _internal_add_senderkeystates();
  // @@protoc_insertion_point(field_add:proto.SenderKeyRecordStructure.senderKeyStates)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderKeyStateStructure >&
SenderKeyRecordStructure::senderkeystates() const {
  // @@protoc_insertion_point(field_list:proto.SenderKeyRecordStructure.senderKeyStates)
  return _impl_.senderkeystates_;
}

// -------------------------------------------------------------------

// SenderKeyStateStructure

// optional uint32 senderKeyId = 1;
inline bool SenderKeyStateStructure::_internal_has_senderkeyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SenderKeyStateStructure::has_senderkeyid() const {
  return _internal_has_senderkeyid();
}
inline void SenderKeyStateStructure::clear_senderkeyid() {
  _impl_.senderkeyid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t SenderKeyStateStructure::_internal_senderkeyid() const {
  return _impl_.senderkeyid_;
}
inline uint32_t SenderKeyStateStructure::senderkeyid() const {
  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderKeyId)
  return _internal_senderkeyid();
}
inline void SenderKeyStateStructure::_internal_set_senderkeyid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.senderkeyid_ = value;
}
inline void SenderKeyStateStructure::set_senderkeyid(uint32_t value) {
  _internal_set_senderkeyid(value);
  // @@protoc_insertion_point(field_set:proto.SenderKeyStateStructure.senderKeyId)
}

// optional .proto.SenderChainKey senderChainKey = 2;
inline bool SenderKeyStateStructure::_internal_has_senderchainkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.senderchainkey_ != nullptr);
  return value;
}
inline bool SenderKeyStateStructure::has_senderchainkey() const {
  return _internal_has_senderchainkey();
}
inline void SenderKeyStateStructure::clear_senderchainkey() {
  if (_impl_.senderchainkey_ != nullptr) _impl_.senderchainkey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SenderChainKey& SenderKeyStateStructure::_internal_senderchainkey() const {
  const ::proto::SenderChainKey* p = _impl_.senderchainkey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SenderChainKey&>(
      ::proto::_SenderChainKey_default_instance_);
}
inline const ::proto::SenderChainKey& SenderKeyStateStructure::senderchainkey() const {
  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderChainKey)
  return _internal_senderchainkey();
}
inline void SenderKeyStateStructure::unsafe_arena_set_allocated_senderchainkey(
    ::proto::SenderChainKey* senderchainkey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchainkey_);
  }
  _impl_.senderchainkey_ = senderchainkey;
  if (senderchainkey) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderChainKey)
}
inline ::proto::SenderChainKey* SenderKeyStateStructure::release_senderchainkey() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SenderChainKey* temp = _impl_.senderchainkey_;
  _impl_.senderchainkey_ = 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 ::proto::SenderChainKey* SenderKeyStateStructure::unsafe_arena_release_senderchainkey() {
  // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderChainKey)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SenderChainKey* temp = _impl_.senderchainkey_;
  _impl_.senderchainkey_ = nullptr;
  return temp;
}
inline ::proto::SenderChainKey* SenderKeyStateStructure::_internal_mutable_senderchainkey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.senderchainkey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SenderChainKey>(GetArenaForAllocation());
    _impl_.senderchainkey_ = p;
  }
  return _impl_.senderchainkey_;
}
inline ::proto::SenderChainKey* SenderKeyStateStructure::mutable_senderchainkey() {
  ::proto::SenderChainKey* _msg = _internal_mutable_senderchainkey();
  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderChainKey)
  return _msg;
}
inline void SenderKeyStateStructure::set_allocated_senderchainkey(::proto::SenderChainKey* senderchainkey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.senderchainkey_;
  }
  if (senderchainkey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchainkey);
    if (message_arena != submessage_arena) {
      senderchainkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, senderchainkey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.senderchainkey_ = senderchainkey;
  // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderChainKey)
}

// optional .proto.SenderSigningKey senderSigningKey = 3;
inline bool SenderKeyStateStructure::_internal_has_sendersigningkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sendersigningkey_ != nullptr);
  return value;
}
inline bool SenderKeyStateStructure::has_sendersigningkey() const {
  return _internal_has_sendersigningkey();
}
inline void SenderKeyStateStructure::clear_sendersigningkey() {
  if (_impl_.sendersigningkey_ != nullptr) _impl_.sendersigningkey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::SenderSigningKey& SenderKeyStateStructure::_internal_sendersigningkey() const {
  const ::proto::SenderSigningKey* p = _impl_.sendersigningkey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SenderSigningKey&>(
      ::proto::_SenderSigningKey_default_instance_);
}
inline const ::proto::SenderSigningKey& SenderKeyStateStructure::sendersigningkey() const {
  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderSigningKey)
  return _internal_sendersigningkey();
}
inline void SenderKeyStateStructure::unsafe_arena_set_allocated_sendersigningkey(
    ::proto::SenderSigningKey* sendersigningkey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sendersigningkey_);
  }
  _impl_.sendersigningkey_ = sendersigningkey;
  if (sendersigningkey) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SenderKeyStateStructure.senderSigningKey)
}
inline ::proto::SenderSigningKey* SenderKeyStateStructure::release_sendersigningkey() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_;
  _impl_.sendersigningkey_ = 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 ::proto::SenderSigningKey* SenderKeyStateStructure::unsafe_arena_release_sendersigningkey() {
  // @@protoc_insertion_point(field_release:proto.SenderKeyStateStructure.senderSigningKey)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SenderSigningKey* temp = _impl_.sendersigningkey_;
  _impl_.sendersigningkey_ = nullptr;
  return temp;
}
inline ::proto::SenderSigningKey* SenderKeyStateStructure::_internal_mutable_sendersigningkey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.sendersigningkey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SenderSigningKey>(GetArenaForAllocation());
    _impl_.sendersigningkey_ = p;
  }
  return _impl_.sendersigningkey_;
}
inline ::proto::SenderSigningKey* SenderKeyStateStructure::mutable_sendersigningkey() {
  ::proto::SenderSigningKey* _msg = _internal_mutable_sendersigningkey();
  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderSigningKey)
  return _msg;
}
inline void SenderKeyStateStructure::set_allocated_sendersigningkey(::proto::SenderSigningKey* sendersigningkey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sendersigningkey_;
  }
  if (sendersigningkey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sendersigningkey);
    if (message_arena != submessage_arena) {
      sendersigningkey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sendersigningkey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.sendersigningkey_ = sendersigningkey;
  // @@protoc_insertion_point(field_set_allocated:proto.SenderKeyStateStructure.senderSigningKey)
}

// repeated .proto.SenderMessageKey senderMessageKeys = 4;
inline int SenderKeyStateStructure::_internal_sendermessagekeys_size() const {
  return _impl_.sendermessagekeys_.size();
}
inline int SenderKeyStateStructure::sendermessagekeys_size() const {
  return _internal_sendermessagekeys_size();
}
inline void SenderKeyStateStructure::clear_sendermessagekeys() {
  _impl_.sendermessagekeys_.Clear();
}
inline ::proto::SenderMessageKey* SenderKeyStateStructure::mutable_sendermessagekeys(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SenderKeyStateStructure.senderMessageKeys)
  return _impl_.sendermessagekeys_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >*
SenderKeyStateStructure::mutable_sendermessagekeys() {
  // @@protoc_insertion_point(field_mutable_list:proto.SenderKeyStateStructure.senderMessageKeys)
  return &_impl_.sendermessagekeys_;
}
inline const ::proto::SenderMessageKey& SenderKeyStateStructure::_internal_sendermessagekeys(int index) const {
  return _impl_.sendermessagekeys_.Get(index);
}
inline const ::proto::SenderMessageKey& SenderKeyStateStructure::sendermessagekeys(int index) const {
  // @@protoc_insertion_point(field_get:proto.SenderKeyStateStructure.senderMessageKeys)
  return _internal_sendermessagekeys(index);
}
inline ::proto::SenderMessageKey* SenderKeyStateStructure::_internal_add_sendermessagekeys() {
  return _impl_.sendermessagekeys_.Add();
}
inline ::proto::SenderMessageKey* SenderKeyStateStructure::add_sendermessagekeys() {
  ::proto::SenderMessageKey* _add = _internal_add_sendermessagekeys();
  // @@protoc_insertion_point(field_add:proto.SenderKeyStateStructure.senderMessageKeys)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SenderMessageKey >&
SenderKeyStateStructure::sendermessagekeys() const {
  // @@protoc_insertion_point(field_list:proto.SenderKeyStateStructure.senderMessageKeys)
  return _impl_.sendermessagekeys_;
}

// -------------------------------------------------------------------

// SenderMessageKey

// optional uint32 iteration = 1;
inline bool SenderMessageKey::_internal_has_iteration() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SenderMessageKey::has_iteration() const {
  return _internal_has_iteration();
}
inline void SenderMessageKey::clear_iteration() {
  _impl_.iteration_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t SenderMessageKey::_internal_iteration() const {
  return _impl_.iteration_;
}
inline uint32_t SenderMessageKey::iteration() const {
  // @@protoc_insertion_point(field_get:proto.SenderMessageKey.iteration)
  return _internal_iteration();
}
inline void SenderMessageKey::_internal_set_iteration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.iteration_ = value;
}
inline void SenderMessageKey::set_iteration(uint32_t value) {
  _internal_set_iteration(value);
  // @@protoc_insertion_point(field_set:proto.SenderMessageKey.iteration)
}

// optional bytes seed = 2;
inline bool SenderMessageKey::_internal_has_seed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SenderMessageKey::has_seed() const {
  return _internal_has_seed();
}
inline void SenderMessageKey::clear_seed() {
  _impl_.seed_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SenderMessageKey::seed() const {
  // @@protoc_insertion_point(field_get:proto.SenderMessageKey.seed)
  return _internal_seed();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SenderMessageKey::set_seed(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.seed_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SenderMessageKey.seed)
}
inline std::string* SenderMessageKey::mutable_seed() {
  std::string* _s = _internal_mutable_seed();
  // @@protoc_insertion_point(field_mutable:proto.SenderMessageKey.seed)
  return _s;
}
inline const std::string& SenderMessageKey::_internal_seed() const {
  return _impl_.seed_.Get();
}
inline void SenderMessageKey::_internal_set_seed(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.seed_.Set(value, GetArenaForAllocation());
}
inline std::string* SenderMessageKey::_internal_mutable_seed() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.seed_.Mutable(GetArenaForAllocation());
}
inline std::string* SenderMessageKey::release_seed() {
  // @@protoc_insertion_point(field_release:proto.SenderMessageKey.seed)
  if (!_internal_has_seed()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.seed_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.seed_.IsDefault()) {
    _impl_.seed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SenderMessageKey::set_allocated_seed(std::string* seed) {
  if (seed != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.seed_.SetAllocated(seed, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.seed_.IsDefault()) {
    _impl_.seed_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SenderMessageKey.seed)
}

// -------------------------------------------------------------------

// SenderSigningKey

// optional bytes public = 1;
inline bool SenderSigningKey::_internal_has_public_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SenderSigningKey::has_public_() const {
  return _internal_has_public_();
}
inline void SenderSigningKey::clear_public_() {
  _impl_.public__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SenderSigningKey::public_() const {
  // @@protoc_insertion_point(field_get:proto.SenderSigningKey.public)
  return _internal_public_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SenderSigningKey::set_public_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.public__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SenderSigningKey.public)
}
inline std::string* SenderSigningKey::mutable_public_() {
  std::string* _s = _internal_mutable_public_();
  // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.public)
  return _s;
}
inline const std::string& SenderSigningKey::_internal_public_() const {
  return _impl_.public__.Get();
}
inline void SenderSigningKey::_internal_set_public_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.public__.Set(value, GetArenaForAllocation());
}
inline std::string* SenderSigningKey::_internal_mutable_public_() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.public__.Mutable(GetArenaForAllocation());
}
inline std::string* SenderSigningKey::release_public_() {
  // @@protoc_insertion_point(field_release:proto.SenderSigningKey.public)
  if (!_internal_has_public_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.public__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.public__.IsDefault()) {
    _impl_.public__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SenderSigningKey::set_allocated_public_(std::string* public_) {
  if (public_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.public__.SetAllocated(public_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.public__.IsDefault()) {
    _impl_.public__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.public)
}

// optional bytes private = 2;
inline bool SenderSigningKey::_internal_has_private_() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SenderSigningKey::has_private_() const {
  return _internal_has_private_();
}
inline void SenderSigningKey::clear_private_() {
  _impl_.private__.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SenderSigningKey::private_() const {
  // @@protoc_insertion_point(field_get:proto.SenderSigningKey.private)
  return _internal_private_();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SenderSigningKey::set_private_(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.private__.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SenderSigningKey.private)
}
inline std::string* SenderSigningKey::mutable_private_() {
  std::string* _s = _internal_mutable_private_();
  // @@protoc_insertion_point(field_mutable:proto.SenderSigningKey.private)
  return _s;
}
inline const std::string& SenderSigningKey::_internal_private_() const {
  return _impl_.private__.Get();
}
inline void SenderSigningKey::_internal_set_private_(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.private__.Set(value, GetArenaForAllocation());
}
inline std::string* SenderSigningKey::_internal_mutable_private_() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.private__.Mutable(GetArenaForAllocation());
}
inline std::string* SenderSigningKey::release_private_() {
  // @@protoc_insertion_point(field_release:proto.SenderSigningKey.private)
  if (!_internal_has_private_()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.private__.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.private__.IsDefault()) {
    _impl_.private__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SenderSigningKey::set_allocated_private_(std::string* private_) {
  if (private_ != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.private__.SetAllocated(private_, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.private__.IsDefault()) {
    _impl_.private__.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SenderSigningKey.private)
}

// -------------------------------------------------------------------

// ServerErrorReceipt

// optional string stanzaId = 1;
inline bool ServerErrorReceipt::_internal_has_stanzaid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ServerErrorReceipt::has_stanzaid() const {
  return _internal_has_stanzaid();
}
inline void ServerErrorReceipt::clear_stanzaid() {
  _impl_.stanzaid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ServerErrorReceipt::stanzaid() const {
  // @@protoc_insertion_point(field_get:proto.ServerErrorReceipt.stanzaId)
  return _internal_stanzaid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ServerErrorReceipt::set_stanzaid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.stanzaid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.ServerErrorReceipt.stanzaId)
}
inline std::string* ServerErrorReceipt::mutable_stanzaid() {
  std::string* _s = _internal_mutable_stanzaid();
  // @@protoc_insertion_point(field_mutable:proto.ServerErrorReceipt.stanzaId)
  return _s;
}
inline const std::string& ServerErrorReceipt::_internal_stanzaid() const {
  return _impl_.stanzaid_.Get();
}
inline void ServerErrorReceipt::_internal_set_stanzaid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.stanzaid_.Set(value, GetArenaForAllocation());
}
inline std::string* ServerErrorReceipt::_internal_mutable_stanzaid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.stanzaid_.Mutable(GetArenaForAllocation());
}
inline std::string* ServerErrorReceipt::release_stanzaid() {
  // @@protoc_insertion_point(field_release:proto.ServerErrorReceipt.stanzaId)
  if (!_internal_has_stanzaid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.stanzaid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void ServerErrorReceipt::set_allocated_stanzaid(std::string* stanzaid) {
  if (stanzaid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.stanzaid_.SetAllocated(stanzaid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.stanzaid_.IsDefault()) {
    _impl_.stanzaid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.ServerErrorReceipt.stanzaId)
}

// -------------------------------------------------------------------

// SessionStructure

// optional uint32 sessionVersion = 1;
inline bool SessionStructure::_internal_has_sessionversion() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SessionStructure::has_sessionversion() const {
  return _internal_has_sessionversion();
}
inline void SessionStructure::clear_sessionversion() {
  _impl_.sessionversion_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t SessionStructure::_internal_sessionversion() const {
  return _impl_.sessionversion_;
}
inline uint32_t SessionStructure::sessionversion() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.sessionVersion)
  return _internal_sessionversion();
}
inline void SessionStructure::_internal_set_sessionversion(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.sessionversion_ = value;
}
inline void SessionStructure::set_sessionversion(uint32_t value) {
  _internal_set_sessionversion(value);
  // @@protoc_insertion_point(field_set:proto.SessionStructure.sessionVersion)
}

// optional bytes localIdentityPublic = 2;
inline bool SessionStructure::_internal_has_localidentitypublic() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SessionStructure::has_localidentitypublic() const {
  return _internal_has_localidentitypublic();
}
inline void SessionStructure::clear_localidentitypublic() {
  _impl_.localidentitypublic_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SessionStructure::localidentitypublic() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.localIdentityPublic)
  return _internal_localidentitypublic();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SessionStructure::set_localidentitypublic(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.localidentitypublic_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SessionStructure.localIdentityPublic)
}
inline std::string* SessionStructure::mutable_localidentitypublic() {
  std::string* _s = _internal_mutable_localidentitypublic();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.localIdentityPublic)
  return _s;
}
inline const std::string& SessionStructure::_internal_localidentitypublic() const {
  return _impl_.localidentitypublic_.Get();
}
inline void SessionStructure::_internal_set_localidentitypublic(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.localidentitypublic_.Set(value, GetArenaForAllocation());
}
inline std::string* SessionStructure::_internal_mutable_localidentitypublic() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.localidentitypublic_.Mutable(GetArenaForAllocation());
}
inline std::string* SessionStructure::release_localidentitypublic() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.localIdentityPublic)
  if (!_internal_has_localidentitypublic()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.localidentitypublic_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitypublic_.IsDefault()) {
    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SessionStructure::set_allocated_localidentitypublic(std::string* localidentitypublic) {
  if (localidentitypublic != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.localidentitypublic_.SetAllocated(localidentitypublic, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.localidentitypublic_.IsDefault()) {
    _impl_.localidentitypublic_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.localIdentityPublic)
}

// optional bytes remoteIdentityPublic = 3;
inline bool SessionStructure::_internal_has_remoteidentitypublic() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SessionStructure::has_remoteidentitypublic() const {
  return _internal_has_remoteidentitypublic();
}
inline void SessionStructure::clear_remoteidentitypublic() {
  _impl_.remoteidentitypublic_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SessionStructure::remoteidentitypublic() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteIdentityPublic)
  return _internal_remoteidentitypublic();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SessionStructure::set_remoteidentitypublic(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.remoteidentitypublic_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteIdentityPublic)
}
inline std::string* SessionStructure::mutable_remoteidentitypublic() {
  std::string* _s = _internal_mutable_remoteidentitypublic();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.remoteIdentityPublic)
  return _s;
}
inline const std::string& SessionStructure::_internal_remoteidentitypublic() const {
  return _impl_.remoteidentitypublic_.Get();
}
inline void SessionStructure::_internal_set_remoteidentitypublic(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.remoteidentitypublic_.Set(value, GetArenaForAllocation());
}
inline std::string* SessionStructure::_internal_mutable_remoteidentitypublic() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.remoteidentitypublic_.Mutable(GetArenaForAllocation());
}
inline std::string* SessionStructure::release_remoteidentitypublic() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.remoteIdentityPublic)
  if (!_internal_has_remoteidentitypublic()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.remoteidentitypublic_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remoteidentitypublic_.IsDefault()) {
    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SessionStructure::set_allocated_remoteidentitypublic(std::string* remoteidentitypublic) {
  if (remoteidentitypublic != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.remoteidentitypublic_.SetAllocated(remoteidentitypublic, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.remoteidentitypublic_.IsDefault()) {
    _impl_.remoteidentitypublic_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.remoteIdentityPublic)
}

// optional bytes rootKey = 4;
inline bool SessionStructure::_internal_has_rootkey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SessionStructure::has_rootkey() const {
  return _internal_has_rootkey();
}
inline void SessionStructure::clear_rootkey() {
  _impl_.rootkey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SessionStructure::rootkey() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.rootKey)
  return _internal_rootkey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SessionStructure::set_rootkey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.rootkey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SessionStructure.rootKey)
}
inline std::string* SessionStructure::mutable_rootkey() {
  std::string* _s = _internal_mutable_rootkey();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.rootKey)
  return _s;
}
inline const std::string& SessionStructure::_internal_rootkey() const {
  return _impl_.rootkey_.Get();
}
inline void SessionStructure::_internal_set_rootkey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.rootkey_.Set(value, GetArenaForAllocation());
}
inline std::string* SessionStructure::_internal_mutable_rootkey() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.rootkey_.Mutable(GetArenaForAllocation());
}
inline std::string* SessionStructure::release_rootkey() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.rootKey)
  if (!_internal_has_rootkey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.rootkey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rootkey_.IsDefault()) {
    _impl_.rootkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SessionStructure::set_allocated_rootkey(std::string* rootkey) {
  if (rootkey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.rootkey_.SetAllocated(rootkey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.rootkey_.IsDefault()) {
    _impl_.rootkey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.rootKey)
}

// optional uint32 previousCounter = 5;
inline bool SessionStructure::_internal_has_previouscounter() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SessionStructure::has_previouscounter() const {
  return _internal_has_previouscounter();
}
inline void SessionStructure::clear_previouscounter() {
  _impl_.previouscounter_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t SessionStructure::_internal_previouscounter() const {
  return _impl_.previouscounter_;
}
inline uint32_t SessionStructure::previouscounter() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.previousCounter)
  return _internal_previouscounter();
}
inline void SessionStructure::_internal_set_previouscounter(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.previouscounter_ = value;
}
inline void SessionStructure::set_previouscounter(uint32_t value) {
  _internal_set_previouscounter(value);
  // @@protoc_insertion_point(field_set:proto.SessionStructure.previousCounter)
}

// optional .proto.Chain senderChain = 6;
inline bool SessionStructure::_internal_has_senderchain() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.senderchain_ != nullptr);
  return value;
}
inline bool SessionStructure::has_senderchain() const {
  return _internal_has_senderchain();
}
inline void SessionStructure::clear_senderchain() {
  if (_impl_.senderchain_ != nullptr) _impl_.senderchain_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::Chain& SessionStructure::_internal_senderchain() const {
  const ::proto::Chain* p = _impl_.senderchain_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Chain&>(
      ::proto::_Chain_default_instance_);
}
inline const ::proto::Chain& SessionStructure::senderchain() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.senderChain)
  return _internal_senderchain();
}
inline void SessionStructure::unsafe_arena_set_allocated_senderchain(
    ::proto::Chain* senderchain) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.senderchain_);
  }
  _impl_.senderchain_ = senderchain;
  if (senderchain) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.senderChain)
}
inline ::proto::Chain* SessionStructure::release_senderchain() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Chain* temp = _impl_.senderchain_;
  _impl_.senderchain_ = 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 ::proto::Chain* SessionStructure::unsafe_arena_release_senderchain() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.senderChain)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::Chain* temp = _impl_.senderchain_;
  _impl_.senderchain_ = nullptr;
  return temp;
}
inline ::proto::Chain* SessionStructure::_internal_mutable_senderchain() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.senderchain_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Chain>(GetArenaForAllocation());
    _impl_.senderchain_ = p;
  }
  return _impl_.senderchain_;
}
inline ::proto::Chain* SessionStructure::mutable_senderchain() {
  ::proto::Chain* _msg = _internal_mutable_senderchain();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.senderChain)
  return _msg;
}
inline void SessionStructure::set_allocated_senderchain(::proto::Chain* senderchain) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.senderchain_;
  }
  if (senderchain) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(senderchain);
    if (message_arena != submessage_arena) {
      senderchain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, senderchain, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.senderchain_ = senderchain;
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.senderChain)
}

// repeated .proto.Chain receiverChains = 7;
inline int SessionStructure::_internal_receiverchains_size() const {
  return _impl_.receiverchains_.size();
}
inline int SessionStructure::receiverchains_size() const {
  return _internal_receiverchains_size();
}
inline void SessionStructure::clear_receiverchains() {
  _impl_.receiverchains_.Clear();
}
inline ::proto::Chain* SessionStructure::mutable_receiverchains(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.receiverChains)
  return _impl_.receiverchains_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >*
SessionStructure::mutable_receiverchains() {
  // @@protoc_insertion_point(field_mutable_list:proto.SessionStructure.receiverChains)
  return &_impl_.receiverchains_;
}
inline const ::proto::Chain& SessionStructure::_internal_receiverchains(int index) const {
  return _impl_.receiverchains_.Get(index);
}
inline const ::proto::Chain& SessionStructure::receiverchains(int index) const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.receiverChains)
  return _internal_receiverchains(index);
}
inline ::proto::Chain* SessionStructure::_internal_add_receiverchains() {
  return _impl_.receiverchains_.Add();
}
inline ::proto::Chain* SessionStructure::add_receiverchains() {
  ::proto::Chain* _add = _internal_add_receiverchains();
  // @@protoc_insertion_point(field_add:proto.SessionStructure.receiverChains)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Chain >&
SessionStructure::receiverchains() const {
  // @@protoc_insertion_point(field_list:proto.SessionStructure.receiverChains)
  return _impl_.receiverchains_;
}

// optional .proto.PendingKeyExchange pendingKeyExchange = 8;
inline bool SessionStructure::_internal_has_pendingkeyexchange() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pendingkeyexchange_ != nullptr);
  return value;
}
inline bool SessionStructure::has_pendingkeyexchange() const {
  return _internal_has_pendingkeyexchange();
}
inline void SessionStructure::clear_pendingkeyexchange() {
  if (_impl_.pendingkeyexchange_ != nullptr) _impl_.pendingkeyexchange_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::PendingKeyExchange& SessionStructure::_internal_pendingkeyexchange() const {
  const ::proto::PendingKeyExchange* p = _impl_.pendingkeyexchange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PendingKeyExchange&>(
      ::proto::_PendingKeyExchange_default_instance_);
}
inline const ::proto::PendingKeyExchange& SessionStructure::pendingkeyexchange() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingKeyExchange)
  return _internal_pendingkeyexchange();
}
inline void SessionStructure::unsafe_arena_set_allocated_pendingkeyexchange(
    ::proto::PendingKeyExchange* pendingkeyexchange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingkeyexchange_);
  }
  _impl_.pendingkeyexchange_ = pendingkeyexchange;
  if (pendingkeyexchange) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingKeyExchange)
}
inline ::proto::PendingKeyExchange* SessionStructure::release_pendingkeyexchange() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_;
  _impl_.pendingkeyexchange_ = 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 ::proto::PendingKeyExchange* SessionStructure::unsafe_arena_release_pendingkeyexchange() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingKeyExchange)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::PendingKeyExchange* temp = _impl_.pendingkeyexchange_;
  _impl_.pendingkeyexchange_ = nullptr;
  return temp;
}
inline ::proto::PendingKeyExchange* SessionStructure::_internal_mutable_pendingkeyexchange() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.pendingkeyexchange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PendingKeyExchange>(GetArenaForAllocation());
    _impl_.pendingkeyexchange_ = p;
  }
  return _impl_.pendingkeyexchange_;
}
inline ::proto::PendingKeyExchange* SessionStructure::mutable_pendingkeyexchange() {
  ::proto::PendingKeyExchange* _msg = _internal_mutable_pendingkeyexchange();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingKeyExchange)
  return _msg;
}
inline void SessionStructure::set_allocated_pendingkeyexchange(::proto::PendingKeyExchange* pendingkeyexchange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pendingkeyexchange_;
  }
  if (pendingkeyexchange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingkeyexchange);
    if (message_arena != submessage_arena) {
      pendingkeyexchange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pendingkeyexchange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.pendingkeyexchange_ = pendingkeyexchange;
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingKeyExchange)
}

// optional .proto.PendingPreKey pendingPreKey = 9;
inline bool SessionStructure::_internal_has_pendingprekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pendingprekey_ != nullptr);
  return value;
}
inline bool SessionStructure::has_pendingprekey() const {
  return _internal_has_pendingprekey();
}
inline void SessionStructure::clear_pendingprekey() {
  if (_impl_.pendingprekey_ != nullptr) _impl_.pendingprekey_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::PendingPreKey& SessionStructure::_internal_pendingprekey() const {
  const ::proto::PendingPreKey* p = _impl_.pendingprekey_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PendingPreKey&>(
      ::proto::_PendingPreKey_default_instance_);
}
inline const ::proto::PendingPreKey& SessionStructure::pendingprekey() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.pendingPreKey)
  return _internal_pendingprekey();
}
inline void SessionStructure::unsafe_arena_set_allocated_pendingprekey(
    ::proto::PendingPreKey* pendingprekey) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pendingprekey_);
  }
  _impl_.pendingprekey_ = pendingprekey;
  if (pendingprekey) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SessionStructure.pendingPreKey)
}
inline ::proto::PendingPreKey* SessionStructure::release_pendingprekey() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::PendingPreKey* temp = _impl_.pendingprekey_;
  _impl_.pendingprekey_ = 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 ::proto::PendingPreKey* SessionStructure::unsafe_arena_release_pendingprekey() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.pendingPreKey)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::PendingPreKey* temp = _impl_.pendingprekey_;
  _impl_.pendingprekey_ = nullptr;
  return temp;
}
inline ::proto::PendingPreKey* SessionStructure::_internal_mutable_pendingprekey() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.pendingprekey_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PendingPreKey>(GetArenaForAllocation());
    _impl_.pendingprekey_ = p;
  }
  return _impl_.pendingprekey_;
}
inline ::proto::PendingPreKey* SessionStructure::mutable_pendingprekey() {
  ::proto::PendingPreKey* _msg = _internal_mutable_pendingprekey();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.pendingPreKey)
  return _msg;
}
inline void SessionStructure::set_allocated_pendingprekey(::proto::PendingPreKey* pendingprekey) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pendingprekey_;
  }
  if (pendingprekey) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pendingprekey);
    if (message_arena != submessage_arena) {
      pendingprekey = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pendingprekey, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.pendingprekey_ = pendingprekey;
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.pendingPreKey)
}

// optional uint32 remoteRegistrationId = 10;
inline bool SessionStructure::_internal_has_remoteregistrationid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SessionStructure::has_remoteregistrationid() const {
  return _internal_has_remoteregistrationid();
}
inline void SessionStructure::clear_remoteregistrationid() {
  _impl_.remoteregistrationid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t SessionStructure::_internal_remoteregistrationid() const {
  return _impl_.remoteregistrationid_;
}
inline uint32_t SessionStructure::remoteregistrationid() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.remoteRegistrationId)
  return _internal_remoteregistrationid();
}
inline void SessionStructure::_internal_set_remoteregistrationid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.remoteregistrationid_ = value;
}
inline void SessionStructure::set_remoteregistrationid(uint32_t value) {
  _internal_set_remoteregistrationid(value);
  // @@protoc_insertion_point(field_set:proto.SessionStructure.remoteRegistrationId)
}

// optional uint32 localRegistrationId = 11;
inline bool SessionStructure::_internal_has_localregistrationid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SessionStructure::has_localregistrationid() const {
  return _internal_has_localregistrationid();
}
inline void SessionStructure::clear_localregistrationid() {
  _impl_.localregistrationid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t SessionStructure::_internal_localregistrationid() const {
  return _impl_.localregistrationid_;
}
inline uint32_t SessionStructure::localregistrationid() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.localRegistrationId)
  return _internal_localregistrationid();
}
inline void SessionStructure::_internal_set_localregistrationid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.localregistrationid_ = value;
}
inline void SessionStructure::set_localregistrationid(uint32_t value) {
  _internal_set_localregistrationid(value);
  // @@protoc_insertion_point(field_set:proto.SessionStructure.localRegistrationId)
}

// optional bool needsRefresh = 12;
inline bool SessionStructure::_internal_has_needsrefresh() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool SessionStructure::has_needsrefresh() const {
  return _internal_has_needsrefresh();
}
inline void SessionStructure::clear_needsrefresh() {
  _impl_.needsrefresh_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool SessionStructure::_internal_needsrefresh() const {
  return _impl_.needsrefresh_;
}
inline bool SessionStructure::needsrefresh() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.needsRefresh)
  return _internal_needsrefresh();
}
inline void SessionStructure::_internal_set_needsrefresh(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.needsrefresh_ = value;
}
inline void SessionStructure::set_needsrefresh(bool value) {
  _internal_set_needsrefresh(value);
  // @@protoc_insertion_point(field_set:proto.SessionStructure.needsRefresh)
}

// optional bytes aliceBaseKey = 13;
inline bool SessionStructure::_internal_has_alicebasekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SessionStructure::has_alicebasekey() const {
  return _internal_has_alicebasekey();
}
inline void SessionStructure::clear_alicebasekey() {
  _impl_.alicebasekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SessionStructure::alicebasekey() const {
  // @@protoc_insertion_point(field_get:proto.SessionStructure.aliceBaseKey)
  return _internal_alicebasekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SessionStructure::set_alicebasekey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.alicebasekey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SessionStructure.aliceBaseKey)
}
inline std::string* SessionStructure::mutable_alicebasekey() {
  std::string* _s = _internal_mutable_alicebasekey();
  // @@protoc_insertion_point(field_mutable:proto.SessionStructure.aliceBaseKey)
  return _s;
}
inline const std::string& SessionStructure::_internal_alicebasekey() const {
  return _impl_.alicebasekey_.Get();
}
inline void SessionStructure::_internal_set_alicebasekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.alicebasekey_.Set(value, GetArenaForAllocation());
}
inline std::string* SessionStructure::_internal_mutable_alicebasekey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.alicebasekey_.Mutable(GetArenaForAllocation());
}
inline std::string* SessionStructure::release_alicebasekey() {
  // @@protoc_insertion_point(field_release:proto.SessionStructure.aliceBaseKey)
  if (!_internal_has_alicebasekey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.alicebasekey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alicebasekey_.IsDefault()) {
    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SessionStructure::set_allocated_alicebasekey(std::string* alicebasekey) {
  if (alicebasekey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.alicebasekey_.SetAllocated(alicebasekey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.alicebasekey_.IsDefault()) {
    _impl_.alicebasekey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SessionStructure.aliceBaseKey)
}

// -------------------------------------------------------------------

// SignedPreKeyRecordStructure

// optional uint32 id = 1;
inline bool SignedPreKeyRecordStructure::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SignedPreKeyRecordStructure::has_id() const {
  return _internal_has_id();
}
inline void SignedPreKeyRecordStructure::clear_id() {
  _impl_.id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t SignedPreKeyRecordStructure::_internal_id() const {
  return _impl_.id_;
}
inline uint32_t SignedPreKeyRecordStructure::id() const {
  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.id)
  return _internal_id();
}
inline void SignedPreKeyRecordStructure::_internal_set_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.id_ = value;
}
inline void SignedPreKeyRecordStructure::set_id(uint32_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.id)
}

// optional bytes publicKey = 2;
inline bool SignedPreKeyRecordStructure::_internal_has_publickey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SignedPreKeyRecordStructure::has_publickey() const {
  return _internal_has_publickey();
}
inline void SignedPreKeyRecordStructure::clear_publickey() {
  _impl_.publickey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SignedPreKeyRecordStructure::publickey() const {
  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.publicKey)
  return _internal_publickey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedPreKeyRecordStructure::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:proto.SignedPreKeyRecordStructure.publicKey)
}
inline std::string* SignedPreKeyRecordStructure::mutable_publickey() {
  std::string* _s = _internal_mutable_publickey();
  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.publicKey)
  return _s;
}
inline const std::string& SignedPreKeyRecordStructure::_internal_publickey() const {
  return _impl_.publickey_.Get();
}
inline void SignedPreKeyRecordStructure::_internal_set_publickey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.publickey_.Set(value, GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::_internal_mutable_publickey() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.publickey_.Mutable(GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::release_publickey() {
  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.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 SignedPreKeyRecordStructure::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:proto.SignedPreKeyRecordStructure.publicKey)
}

// optional bytes privateKey = 3;
inline bool SignedPreKeyRecordStructure::_internal_has_privatekey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SignedPreKeyRecordStructure::has_privatekey() const {
  return _internal_has_privatekey();
}
inline void SignedPreKeyRecordStructure::clear_privatekey() {
  _impl_.privatekey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SignedPreKeyRecordStructure::privatekey() const {
  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.privateKey)
  return _internal_privatekey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedPreKeyRecordStructure::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:proto.SignedPreKeyRecordStructure.privateKey)
}
inline std::string* SignedPreKeyRecordStructure::mutable_privatekey() {
  std::string* _s = _internal_mutable_privatekey();
  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.privateKey)
  return _s;
}
inline const std::string& SignedPreKeyRecordStructure::_internal_privatekey() const {
  return _impl_.privatekey_.Get();
}
inline void SignedPreKeyRecordStructure::_internal_set_privatekey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.privatekey_.Set(value, GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::_internal_mutable_privatekey() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.privatekey_.Mutable(GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::release_privatekey() {
  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.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 SignedPreKeyRecordStructure::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:proto.SignedPreKeyRecordStructure.privateKey)
}

// optional bytes signature = 4;
inline bool SignedPreKeyRecordStructure::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SignedPreKeyRecordStructure::has_signature() const {
  return _internal_has_signature();
}
inline void SignedPreKeyRecordStructure::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SignedPreKeyRecordStructure::signature() const {
  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SignedPreKeyRecordStructure::set_signature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.signature)
}
inline std::string* SignedPreKeyRecordStructure::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:proto.SignedPreKeyRecordStructure.signature)
  return _s;
}
inline const std::string& SignedPreKeyRecordStructure::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void SignedPreKeyRecordStructure::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* SignedPreKeyRecordStructure::release_signature() {
  // @@protoc_insertion_point(field_release:proto.SignedPreKeyRecordStructure.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.signature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SignedPreKeyRecordStructure::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SignedPreKeyRecordStructure.signature)
}

// optional fixed64 timestamp = 5;
inline bool SignedPreKeyRecordStructure::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SignedPreKeyRecordStructure::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void SignedPreKeyRecordStructure::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t SignedPreKeyRecordStructure::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t SignedPreKeyRecordStructure::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.SignedPreKeyRecordStructure.timestamp)
  return _internal_timestamp();
}
inline void SignedPreKeyRecordStructure::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.timestamp_ = value;
}
inline void SignedPreKeyRecordStructure::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.SignedPreKeyRecordStructure.timestamp)
}

// -------------------------------------------------------------------

// StatusPSA

// required uint64 campaignId = 44;
inline bool StatusPSA::_internal_has_campaignid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool StatusPSA::has_campaignid() const {
  return _internal_has_campaignid();
}
inline void StatusPSA::clear_campaignid() {
  _impl_.campaignid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t StatusPSA::_internal_campaignid() const {
  return _impl_.campaignid_;
}
inline uint64_t StatusPSA::campaignid() const {
  // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignId)
  return _internal_campaignid();
}
inline void StatusPSA::_internal_set_campaignid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.campaignid_ = value;
}
inline void StatusPSA::set_campaignid(uint64_t value) {
  _internal_set_campaignid(value);
  // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignId)
}

// optional uint64 campaignExpirationTimestamp = 45;
inline bool StatusPSA::_internal_has_campaignexpirationtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool StatusPSA::has_campaignexpirationtimestamp() const {
  return _internal_has_campaignexpirationtimestamp();
}
inline void StatusPSA::clear_campaignexpirationtimestamp() {
  _impl_.campaignexpirationtimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t StatusPSA::_internal_campaignexpirationtimestamp() const {
  return _impl_.campaignexpirationtimestamp_;
}
inline uint64_t StatusPSA::campaignexpirationtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.StatusPSA.campaignExpirationTimestamp)
  return _internal_campaignexpirationtimestamp();
}
inline void StatusPSA::_internal_set_campaignexpirationtimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.campaignexpirationtimestamp_ = value;
}
inline void StatusPSA::set_campaignexpirationtimestamp(uint64_t value) {
  _internal_set_campaignexpirationtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.StatusPSA.campaignExpirationTimestamp)
}

// -------------------------------------------------------------------

// StickerMetadata

// optional string url = 1;
inline bool StickerMetadata::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool StickerMetadata::has_url() const {
  return _internal_has_url();
}
inline void StickerMetadata::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& StickerMetadata::url() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::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:proto.StickerMetadata.url)
}
inline std::string* StickerMetadata::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.url)
  return _s;
}
inline const std::string& StickerMetadata::_internal_url() const {
  return _impl_.url_.Get();
}
inline void StickerMetadata::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_url() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.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 StickerMetadata::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:proto.StickerMetadata.url)
}

// optional bytes fileSha256 = 2;
inline bool StickerMetadata::_internal_has_filesha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool StickerMetadata::has_filesha256() const {
  return _internal_has_filesha256();
}
inline void StickerMetadata::clear_filesha256() {
  _impl_.filesha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& StickerMetadata::filesha256() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileSha256)
  return _internal_filesha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::set_filesha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.filesha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileSha256)
}
inline std::string* StickerMetadata::mutable_filesha256() {
  std::string* _s = _internal_mutable_filesha256();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileSha256)
  return _s;
}
inline const std::string& StickerMetadata::_internal_filesha256() const {
  return _impl_.filesha256_.Get();
}
inline void StickerMetadata::_internal_set_filesha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.filesha256_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_filesha256() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.filesha256_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_filesha256() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileSha256)
  if (!_internal_has_filesha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.filesha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void StickerMetadata::set_allocated_filesha256(std::string* filesha256) {
  if (filesha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.filesha256_.SetAllocated(filesha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.filesha256_.IsDefault()) {
    _impl_.filesha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileSha256)
}

// optional bytes fileEncSha256 = 3;
inline bool StickerMetadata::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool StickerMetadata::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void StickerMetadata::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& StickerMetadata::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileEncSha256)
}
inline std::string* StickerMetadata::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.fileEncSha256)
  return _s;
}
inline const std::string& StickerMetadata::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void StickerMetadata::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void StickerMetadata::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.fileEncSha256)
}

// optional bytes mediaKey = 4;
inline bool StickerMetadata::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool StickerMetadata::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void StickerMetadata::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& StickerMetadata::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.mediaKey)
}
inline std::string* StickerMetadata::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mediaKey)
  return _s;
}
inline const std::string& StickerMetadata::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void StickerMetadata::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void StickerMetadata::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mediaKey)
}

// optional string mimetype = 5;
inline bool StickerMetadata::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool StickerMetadata::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void StickerMetadata::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& StickerMetadata::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.mimetype)
}
inline std::string* StickerMetadata::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.mimetype)
  return _s;
}
inline const std::string& StickerMetadata::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void StickerMetadata::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void StickerMetadata::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.mimetype)
}

// optional uint32 height = 6;
inline bool StickerMetadata::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool StickerMetadata::has_height() const {
  return _internal_has_height();
}
inline void StickerMetadata::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t StickerMetadata::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t StickerMetadata::height() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.height)
  return _internal_height();
}
inline void StickerMetadata::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.height_ = value;
}
inline void StickerMetadata::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.height)
}

// optional uint32 width = 7;
inline bool StickerMetadata::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool StickerMetadata::has_width() const {
  return _internal_has_width();
}
inline void StickerMetadata::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t StickerMetadata::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t StickerMetadata::width() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.width)
  return _internal_width();
}
inline void StickerMetadata::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.width_ = value;
}
inline void StickerMetadata::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.width)
}

// optional string directPath = 8;
inline bool StickerMetadata::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool StickerMetadata::has_directpath() const {
  return _internal_has_directpath();
}
inline void StickerMetadata::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& StickerMetadata::directpath() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StickerMetadata::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.directPath)
}
inline std::string* StickerMetadata::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.StickerMetadata.directPath)
  return _s;
}
inline const std::string& StickerMetadata::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void StickerMetadata::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* StickerMetadata::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* StickerMetadata::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.StickerMetadata.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void StickerMetadata::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.StickerMetadata.directPath)
}

// optional uint64 fileLength = 9;
inline bool StickerMetadata::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool StickerMetadata::has_filelength() const {
  return _internal_has_filelength();
}
inline void StickerMetadata::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t StickerMetadata::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t StickerMetadata::filelength() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.fileLength)
  return _internal_filelength();
}
inline void StickerMetadata::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.filelength_ = value;
}
inline void StickerMetadata::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.fileLength)
}

// optional float weight = 10;
inline bool StickerMetadata::_internal_has_weight() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool StickerMetadata::has_weight() const {
  return _internal_has_weight();
}
inline void StickerMetadata::clear_weight() {
  _impl_.weight_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline float StickerMetadata::_internal_weight() const {
  return _impl_.weight_;
}
inline float StickerMetadata::weight() const {
  // @@protoc_insertion_point(field_get:proto.StickerMetadata.weight)
  return _internal_weight();
}
inline void StickerMetadata::_internal_set_weight(float value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.weight_ = value;
}
inline void StickerMetadata::set_weight(float value) {
  _internal_set_weight(value);
  // @@protoc_insertion_point(field_set:proto.StickerMetadata.weight)
}

// -------------------------------------------------------------------

// SyncActionData

// optional bytes index = 1;
inline bool SyncActionData::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionData::has_index() const {
  return _internal_has_index();
}
inline void SyncActionData::clear_index() {
  _impl_.index_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionData::index() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionData.index)
  return _internal_index();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionData::set_index(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.index_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionData.index)
}
inline std::string* SyncActionData::mutable_index() {
  std::string* _s = _internal_mutable_index();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.index)
  return _s;
}
inline const std::string& SyncActionData::_internal_index() const {
  return _impl_.index_.Get();
}
inline void SyncActionData::_internal_set_index(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.index_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionData::_internal_mutable_index() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.index_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionData::release_index() {
  // @@protoc_insertion_point(field_release:proto.SyncActionData.index)
  if (!_internal_has_index()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.index_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.index_.IsDefault()) {
    _impl_.index_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionData::set_allocated_index(std::string* index) {
  if (index != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.index_.SetAllocated(index, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.index_.IsDefault()) {
    _impl_.index_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.index)
}

// optional .proto.SyncActionValue value = 2;
inline bool SyncActionData::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline bool SyncActionData::has_value() const {
  return _internal_has_value();
}
inline void SyncActionData::clear_value() {
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::SyncActionValue& SyncActionData::_internal_value() const {
  const ::proto::SyncActionValue* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue&>(
      ::proto::_SyncActionValue_default_instance_);
}
inline const ::proto::SyncActionValue& SyncActionData::value() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionData.value)
  return _internal_value();
}
inline void SyncActionData::unsafe_arena_set_allocated_value(
    ::proto::SyncActionValue* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionData.value)
}
inline ::proto::SyncActionValue* SyncActionData::release_value() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncActionValue* temp = _impl_.value_;
  _impl_.value_ = 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 ::proto::SyncActionValue* SyncActionData::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:proto.SyncActionData.value)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncActionValue* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue* SyncActionData::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::proto::SyncActionValue* SyncActionData::mutable_value() {
  ::proto::SyncActionValue* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.value)
  return _msg;
}
inline void SyncActionData::set_allocated_value(::proto::SyncActionValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.value)
}

// optional bytes padding = 3;
inline bool SyncActionData::_internal_has_padding() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionData::has_padding() const {
  return _internal_has_padding();
}
inline void SyncActionData::clear_padding() {
  _impl_.padding_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SyncActionData::padding() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionData.padding)
  return _internal_padding();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionData::set_padding(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.padding_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionData.padding)
}
inline std::string* SyncActionData::mutable_padding() {
  std::string* _s = _internal_mutable_padding();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionData.padding)
  return _s;
}
inline const std::string& SyncActionData::_internal_padding() const {
  return _impl_.padding_.Get();
}
inline void SyncActionData::_internal_set_padding(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.padding_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionData::_internal_mutable_padding() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.padding_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionData::release_padding() {
  // @@protoc_insertion_point(field_release:proto.SyncActionData.padding)
  if (!_internal_has_padding()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.padding_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.padding_.IsDefault()) {
    _impl_.padding_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionData::set_allocated_padding(std::string* padding) {
  if (padding != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.padding_.SetAllocated(padding, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.padding_.IsDefault()) {
    _impl_.padding_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionData.padding)
}

// optional int32 version = 4;
inline bool SyncActionData::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SyncActionData::has_version() const {
  return _internal_has_version();
}
inline void SyncActionData::clear_version() {
  _impl_.version_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int32_t SyncActionData::_internal_version() const {
  return _impl_.version_;
}
inline int32_t SyncActionData::version() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionData.version)
  return _internal_version();
}
inline void SyncActionData::_internal_set_version(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.version_ = value;
}
inline void SyncActionData::set_version(int32_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionData.version)
}

// -------------------------------------------------------------------

// SyncActionValue_AgentAction

// optional string name = 1;
inline bool SyncActionValue_AgentAction::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_AgentAction::has_name() const {
  return _internal_has_name();
}
inline void SyncActionValue_AgentAction::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_AgentAction::name() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_AgentAction::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.name)
}
inline std::string* SyncActionValue_AgentAction::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.AgentAction.name)
  return _s;
}
inline const std::string& SyncActionValue_AgentAction::_internal_name() const {
  return _impl_.name_.Get();
}
inline void SyncActionValue_AgentAction::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_AgentAction::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_AgentAction::release_name() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.AgentAction.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 SyncActionValue_AgentAction::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.SyncActionValue.AgentAction.name)
}

// optional int32 deviceID = 2;
inline bool SyncActionValue_AgentAction::_internal_has_deviceid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_AgentAction::has_deviceid() const {
  return _internal_has_deviceid();
}
inline void SyncActionValue_AgentAction::clear_deviceid() {
  _impl_.deviceid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SyncActionValue_AgentAction::_internal_deviceid() const {
  return _impl_.deviceid_;
}
inline int32_t SyncActionValue_AgentAction::deviceid() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.deviceID)
  return _internal_deviceid();
}
inline void SyncActionValue_AgentAction::_internal_set_deviceid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.deviceid_ = value;
}
inline void SyncActionValue_AgentAction::set_deviceid(int32_t value) {
  _internal_set_deviceid(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.deviceID)
}

// optional bool isDeleted = 3;
inline bool SyncActionValue_AgentAction::_internal_has_isdeleted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SyncActionValue_AgentAction::has_isdeleted() const {
  return _internal_has_isdeleted();
}
inline void SyncActionValue_AgentAction::clear_isdeleted() {
  _impl_.isdeleted_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool SyncActionValue_AgentAction::_internal_isdeleted() const {
  return _impl_.isdeleted_;
}
inline bool SyncActionValue_AgentAction::isdeleted() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AgentAction.isDeleted)
  return _internal_isdeleted();
}
inline void SyncActionValue_AgentAction::_internal_set_isdeleted(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.isdeleted_ = value;
}
inline void SyncActionValue_AgentAction::set_isdeleted(bool value) {
  _internal_set_isdeleted(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AgentAction.isDeleted)
}

// -------------------------------------------------------------------

// SyncActionValue_AndroidUnsupportedActions

// optional bool allowed = 1;
inline bool SyncActionValue_AndroidUnsupportedActions::_internal_has_allowed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_AndroidUnsupportedActions::has_allowed() const {
  return _internal_has_allowed();
}
inline void SyncActionValue_AndroidUnsupportedActions::clear_allowed() {
  _impl_.allowed_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_AndroidUnsupportedActions::_internal_allowed() const {
  return _impl_.allowed_;
}
inline bool SyncActionValue_AndroidUnsupportedActions::allowed() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.AndroidUnsupportedActions.allowed)
  return _internal_allowed();
}
inline void SyncActionValue_AndroidUnsupportedActions::_internal_set_allowed(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.allowed_ = value;
}
inline void SyncActionValue_AndroidUnsupportedActions::set_allowed(bool value) {
  _internal_set_allowed(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.AndroidUnsupportedActions.allowed)
}

// -------------------------------------------------------------------

// SyncActionValue_ArchiveChatAction

// optional bool archived = 1;
inline bool SyncActionValue_ArchiveChatAction::_internal_has_archived() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_ArchiveChatAction::has_archived() const {
  return _internal_has_archived();
}
inline void SyncActionValue_ArchiveChatAction::clear_archived() {
  _impl_.archived_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SyncActionValue_ArchiveChatAction::_internal_archived() const {
  return _impl_.archived_;
}
inline bool SyncActionValue_ArchiveChatAction::archived() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.archived)
  return _internal_archived();
}
inline void SyncActionValue_ArchiveChatAction::_internal_set_archived(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.archived_ = value;
}
inline void SyncActionValue_ArchiveChatAction::set_archived(bool value) {
  _internal_set_archived(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ArchiveChatAction.archived)
}

// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
inline bool SyncActionValue_ArchiveChatAction::_internal_has_messagerange() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
  return value;
}
inline bool SyncActionValue_ArchiveChatAction::has_messagerange() const {
  return _internal_has_messagerange();
}
inline void SyncActionValue_ArchiveChatAction::clear_messagerange() {
  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::_internal_messagerange() const {
  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ArchiveChatAction::messagerange() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ArchiveChatAction.messageRange)
  return _internal_messagerange();
}
inline void SyncActionValue_ArchiveChatAction::unsafe_arena_set_allocated_messagerange(
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
  }
  _impl_.messagerange_ = messagerange;
  if (messagerange) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange)
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::release_messagerange() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = 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 ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::unsafe_arena_release_messagerange() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ArchiveChatAction.messageRange)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::_internal_mutable_messagerange() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.messagerange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
    _impl_.messagerange_ = p;
  }
  return _impl_.messagerange_;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ArchiveChatAction::mutable_messagerange() {
  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ArchiveChatAction.messageRange)
  return _msg;
}
inline void SyncActionValue_ArchiveChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagerange_;
  }
  if (messagerange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
    if (message_arena != submessage_arena) {
      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagerange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagerange_ = messagerange;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ArchiveChatAction.messageRange)
}

// -------------------------------------------------------------------

// SyncActionValue_ClearChatAction

// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
inline bool SyncActionValue_ClearChatAction::_internal_has_messagerange() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
  return value;
}
inline bool SyncActionValue_ClearChatAction::has_messagerange() const {
  return _internal_has_messagerange();
}
inline void SyncActionValue_ClearChatAction::clear_messagerange() {
  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::_internal_messagerange() const {
  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_ClearChatAction::messagerange() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ClearChatAction.messageRange)
  return _internal_messagerange();
}
inline void SyncActionValue_ClearChatAction::unsafe_arena_set_allocated_messagerange(
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
  }
  _impl_.messagerange_ = messagerange;
  if (messagerange) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange)
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::release_messagerange() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = 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 ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::unsafe_arena_release_messagerange() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ClearChatAction.messageRange)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::_internal_mutable_messagerange() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.messagerange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
    _impl_.messagerange_ = p;
  }
  return _impl_.messagerange_;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_ClearChatAction::mutable_messagerange() {
  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ClearChatAction.messageRange)
  return _msg;
}
inline void SyncActionValue_ClearChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagerange_;
  }
  if (messagerange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
    if (message_arena != submessage_arena) {
      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagerange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagerange_ = messagerange;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ClearChatAction.messageRange)
}

// -------------------------------------------------------------------

// SyncActionValue_ContactAction

// optional string fullName = 1;
inline bool SyncActionValue_ContactAction::_internal_has_fullname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_ContactAction::has_fullname() const {
  return _internal_has_fullname();
}
inline void SyncActionValue_ContactAction::clear_fullname() {
  _impl_.fullname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_ContactAction::fullname() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.fullName)
  return _internal_fullname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_ContactAction::set_fullname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.fullname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.fullName)
}
inline std::string* SyncActionValue_ContactAction::mutable_fullname() {
  std::string* _s = _internal_mutable_fullname();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.fullName)
  return _s;
}
inline const std::string& SyncActionValue_ContactAction::_internal_fullname() const {
  return _impl_.fullname_.Get();
}
inline void SyncActionValue_ContactAction::_internal_set_fullname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.fullname_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_ContactAction::_internal_mutable_fullname() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.fullname_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_ContactAction::release_fullname() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.fullName)
  if (!_internal_has_fullname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.fullname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fullname_.IsDefault()) {
    _impl_.fullname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_ContactAction::set_allocated_fullname(std::string* fullname) {
  if (fullname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.fullname_.SetAllocated(fullname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fullname_.IsDefault()) {
    _impl_.fullname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.fullName)
}

// optional string firstName = 2;
inline bool SyncActionValue_ContactAction::_internal_has_firstname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_ContactAction::has_firstname() const {
  return _internal_has_firstname();
}
inline void SyncActionValue_ContactAction::clear_firstname() {
  _impl_.firstname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SyncActionValue_ContactAction::firstname() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.ContactAction.firstName)
  return _internal_firstname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_ContactAction::set_firstname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.firstname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.ContactAction.firstName)
}
inline std::string* SyncActionValue_ContactAction::mutable_firstname() {
  std::string* _s = _internal_mutable_firstname();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.ContactAction.firstName)
  return _s;
}
inline const std::string& SyncActionValue_ContactAction::_internal_firstname() const {
  return _impl_.firstname_.Get();
}
inline void SyncActionValue_ContactAction::_internal_set_firstname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.firstname_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_ContactAction::_internal_mutable_firstname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.firstname_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_ContactAction::release_firstname() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.ContactAction.firstName)
  if (!_internal_has_firstname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.firstname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstname_.IsDefault()) {
    _impl_.firstname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_ContactAction::set_allocated_firstname(std::string* firstname) {
  if (firstname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.firstname_.SetAllocated(firstname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.firstname_.IsDefault()) {
    _impl_.firstname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.ContactAction.firstName)
}

// -------------------------------------------------------------------

// SyncActionValue_DeleteChatAction

// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 1;
inline bool SyncActionValue_DeleteChatAction::_internal_has_messagerange() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
  return value;
}
inline bool SyncActionValue_DeleteChatAction::has_messagerange() const {
  return _internal_has_messagerange();
}
inline void SyncActionValue_DeleteChatAction::clear_messagerange() {
  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::_internal_messagerange() const {
  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_DeleteChatAction::messagerange() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteChatAction.messageRange)
  return _internal_messagerange();
}
inline void SyncActionValue_DeleteChatAction::unsafe_arena_set_allocated_messagerange(
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
  }
  _impl_.messagerange_ = messagerange;
  if (messagerange) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange)
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::release_messagerange() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = 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 ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::unsafe_arena_release_messagerange() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.DeleteChatAction.messageRange)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::_internal_mutable_messagerange() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.messagerange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
    _impl_.messagerange_ = p;
  }
  return _impl_.messagerange_;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_DeleteChatAction::mutable_messagerange() {
  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.DeleteChatAction.messageRange)
  return _msg;
}
inline void SyncActionValue_DeleteChatAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagerange_;
  }
  if (messagerange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
    if (message_arena != submessage_arena) {
      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagerange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagerange_ = messagerange;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.DeleteChatAction.messageRange)
}

// -------------------------------------------------------------------

// SyncActionValue_DeleteMessageForMeAction

// optional bool deleteMedia = 1;
inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_deletemedia() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_DeleteMessageForMeAction::has_deletemedia() const {
  return _internal_has_deletemedia();
}
inline void SyncActionValue_DeleteMessageForMeAction::clear_deletemedia() {
  _impl_.deletemedia_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SyncActionValue_DeleteMessageForMeAction::_internal_deletemedia() const {
  return _impl_.deletemedia_;
}
inline bool SyncActionValue_DeleteMessageForMeAction::deletemedia() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia)
  return _internal_deletemedia();
}
inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_deletemedia(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.deletemedia_ = value;
}
inline void SyncActionValue_DeleteMessageForMeAction::set_deletemedia(bool value) {
  _internal_set_deletemedia(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.deleteMedia)
}

// optional int64 messageTimestamp = 2;
inline bool SyncActionValue_DeleteMessageForMeAction::_internal_has_messagetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_DeleteMessageForMeAction::has_messagetimestamp() const {
  return _internal_has_messagetimestamp();
}
inline void SyncActionValue_DeleteMessageForMeAction::clear_messagetimestamp() {
  _impl_.messagetimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SyncActionValue_DeleteMessageForMeAction::_internal_messagetimestamp() const {
  return _impl_.messagetimestamp_;
}
inline int64_t SyncActionValue_DeleteMessageForMeAction::messagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp)
  return _internal_messagetimestamp();
}
inline void SyncActionValue_DeleteMessageForMeAction::_internal_set_messagetimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.messagetimestamp_ = value;
}
inline void SyncActionValue_DeleteMessageForMeAction::set_messagetimestamp(int64_t value) {
  _internal_set_messagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.DeleteMessageForMeAction.messageTimestamp)
}

// -------------------------------------------------------------------

// SyncActionValue_KeyExpiration

// optional int32 expiredKeyEpoch = 1;
inline bool SyncActionValue_KeyExpiration::_internal_has_expiredkeyepoch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_KeyExpiration::has_expiredkeyepoch() const {
  return _internal_has_expiredkeyepoch();
}
inline void SyncActionValue_KeyExpiration::clear_expiredkeyepoch() {
  _impl_.expiredkeyepoch_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int32_t SyncActionValue_KeyExpiration::_internal_expiredkeyepoch() const {
  return _impl_.expiredkeyepoch_;
}
inline int32_t SyncActionValue_KeyExpiration::expiredkeyepoch() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch)
  return _internal_expiredkeyepoch();
}
inline void SyncActionValue_KeyExpiration::_internal_set_expiredkeyepoch(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.expiredkeyepoch_ = value;
}
inline void SyncActionValue_KeyExpiration::set_expiredkeyepoch(int32_t value) {
  _internal_set_expiredkeyepoch(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.KeyExpiration.expiredKeyEpoch)
}

// -------------------------------------------------------------------

// SyncActionValue_LabelAssociationAction

// optional bool labeled = 1;
inline bool SyncActionValue_LabelAssociationAction::_internal_has_labeled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_LabelAssociationAction::has_labeled() const {
  return _internal_has_labeled();
}
inline void SyncActionValue_LabelAssociationAction::clear_labeled() {
  _impl_.labeled_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_LabelAssociationAction::_internal_labeled() const {
  return _impl_.labeled_;
}
inline bool SyncActionValue_LabelAssociationAction::labeled() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelAssociationAction.labeled)
  return _internal_labeled();
}
inline void SyncActionValue_LabelAssociationAction::_internal_set_labeled(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.labeled_ = value;
}
inline void SyncActionValue_LabelAssociationAction::set_labeled(bool value) {
  _internal_set_labeled(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelAssociationAction.labeled)
}

// -------------------------------------------------------------------

// SyncActionValue_LabelEditAction

// optional string name = 1;
inline bool SyncActionValue_LabelEditAction::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_LabelEditAction::has_name() const {
  return _internal_has_name();
}
inline void SyncActionValue_LabelEditAction::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_LabelEditAction::name() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_LabelEditAction::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.name)
}
inline std::string* SyncActionValue_LabelEditAction::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LabelEditAction.name)
  return _s;
}
inline const std::string& SyncActionValue_LabelEditAction::_internal_name() const {
  return _impl_.name_.Get();
}
inline void SyncActionValue_LabelEditAction::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_LabelEditAction::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_LabelEditAction::release_name() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.LabelEditAction.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 SyncActionValue_LabelEditAction::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.SyncActionValue.LabelEditAction.name)
}

// optional int32 color = 2;
inline bool SyncActionValue_LabelEditAction::_internal_has_color() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_LabelEditAction::has_color() const {
  return _internal_has_color();
}
inline void SyncActionValue_LabelEditAction::clear_color() {
  _impl_.color_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int32_t SyncActionValue_LabelEditAction::_internal_color() const {
  return _impl_.color_;
}
inline int32_t SyncActionValue_LabelEditAction::color() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.color)
  return _internal_color();
}
inline void SyncActionValue_LabelEditAction::_internal_set_color(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.color_ = value;
}
inline void SyncActionValue_LabelEditAction::set_color(int32_t value) {
  _internal_set_color(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.color)
}

// optional int32 predefinedId = 3;
inline bool SyncActionValue_LabelEditAction::_internal_has_predefinedid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SyncActionValue_LabelEditAction::has_predefinedid() const {
  return _internal_has_predefinedid();
}
inline void SyncActionValue_LabelEditAction::clear_predefinedid() {
  _impl_.predefinedid_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SyncActionValue_LabelEditAction::_internal_predefinedid() const {
  return _impl_.predefinedid_;
}
inline int32_t SyncActionValue_LabelEditAction::predefinedid() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.predefinedId)
  return _internal_predefinedid();
}
inline void SyncActionValue_LabelEditAction::_internal_set_predefinedid(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.predefinedid_ = value;
}
inline void SyncActionValue_LabelEditAction::set_predefinedid(int32_t value) {
  _internal_set_predefinedid(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.predefinedId)
}

// optional bool deleted = 4;
inline bool SyncActionValue_LabelEditAction::_internal_has_deleted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SyncActionValue_LabelEditAction::has_deleted() const {
  return _internal_has_deleted();
}
inline void SyncActionValue_LabelEditAction::clear_deleted() {
  _impl_.deleted_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool SyncActionValue_LabelEditAction::_internal_deleted() const {
  return _impl_.deleted_;
}
inline bool SyncActionValue_LabelEditAction::deleted() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LabelEditAction.deleted)
  return _internal_deleted();
}
inline void SyncActionValue_LabelEditAction::_internal_set_deleted(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.deleted_ = value;
}
inline void SyncActionValue_LabelEditAction::set_deleted(bool value) {
  _internal_set_deleted(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LabelEditAction.deleted)
}

// -------------------------------------------------------------------

// SyncActionValue_LocaleSetting

// optional string locale = 1;
inline bool SyncActionValue_LocaleSetting::_internal_has_locale() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_LocaleSetting::has_locale() const {
  return _internal_has_locale();
}
inline void SyncActionValue_LocaleSetting::clear_locale() {
  _impl_.locale_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_LocaleSetting::locale() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.LocaleSetting.locale)
  return _internal_locale();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_LocaleSetting::set_locale(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.locale_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.LocaleSetting.locale)
}
inline std::string* SyncActionValue_LocaleSetting::mutable_locale() {
  std::string* _s = _internal_mutable_locale();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.LocaleSetting.locale)
  return _s;
}
inline const std::string& SyncActionValue_LocaleSetting::_internal_locale() const {
  return _impl_.locale_.Get();
}
inline void SyncActionValue_LocaleSetting::_internal_set_locale(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.locale_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_LocaleSetting::_internal_mutable_locale() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.locale_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_LocaleSetting::release_locale() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.LocaleSetting.locale)
  if (!_internal_has_locale()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.locale_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.locale_.IsDefault()) {
    _impl_.locale_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_LocaleSetting::set_allocated_locale(std::string* locale) {
  if (locale != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.locale_.SetAllocated(locale, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.locale_.IsDefault()) {
    _impl_.locale_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.LocaleSetting.locale)
}

// -------------------------------------------------------------------

// SyncActionValue_MarkChatAsReadAction

// optional bool read = 1;
inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_read() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_MarkChatAsReadAction::has_read() const {
  return _internal_has_read();
}
inline void SyncActionValue_MarkChatAsReadAction::clear_read() {
  _impl_.read_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SyncActionValue_MarkChatAsReadAction::_internal_read() const {
  return _impl_.read_;
}
inline bool SyncActionValue_MarkChatAsReadAction::read() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.read)
  return _internal_read();
}
inline void SyncActionValue_MarkChatAsReadAction::_internal_set_read(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.read_ = value;
}
inline void SyncActionValue_MarkChatAsReadAction::set_read(bool value) {
  _internal_set_read(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MarkChatAsReadAction.read)
}

// optional .proto.SyncActionValue.SyncActionMessageRange messageRange = 2;
inline bool SyncActionValue_MarkChatAsReadAction::_internal_has_messagerange() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.messagerange_ != nullptr);
  return value;
}
inline bool SyncActionValue_MarkChatAsReadAction::has_messagerange() const {
  return _internal_has_messagerange();
}
inline void SyncActionValue_MarkChatAsReadAction::clear_messagerange() {
  if (_impl_.messagerange_ != nullptr) _impl_.messagerange_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::_internal_messagerange() const {
  const ::proto::SyncActionValue_SyncActionMessageRange* p = _impl_.messagerange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SyncActionMessageRange&>(
      ::proto::_SyncActionValue_SyncActionMessageRange_default_instance_);
}
inline const ::proto::SyncActionValue_SyncActionMessageRange& SyncActionValue_MarkChatAsReadAction::messagerange() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
  return _internal_messagerange();
}
inline void SyncActionValue_MarkChatAsReadAction::unsafe_arena_set_allocated_messagerange(
    ::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messagerange_);
  }
  _impl_.messagerange_ = messagerange;
  if (messagerange) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::release_messagerange() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = 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 ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::unsafe_arena_release_messagerange() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_SyncActionMessageRange* temp = _impl_.messagerange_;
  _impl_.messagerange_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::_internal_mutable_messagerange() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.messagerange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SyncActionMessageRange>(GetArenaForAllocation());
    _impl_.messagerange_ = p;
  }
  return _impl_.messagerange_;
}
inline ::proto::SyncActionValue_SyncActionMessageRange* SyncActionValue_MarkChatAsReadAction::mutable_messagerange() {
  ::proto::SyncActionValue_SyncActionMessageRange* _msg = _internal_mutable_messagerange();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
  return _msg;
}
inline void SyncActionValue_MarkChatAsReadAction::set_allocated_messagerange(::proto::SyncActionValue_SyncActionMessageRange* messagerange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.messagerange_;
  }
  if (messagerange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(messagerange);
    if (message_arena != submessage_arena) {
      messagerange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, messagerange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.messagerange_ = messagerange;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.MarkChatAsReadAction.messageRange)
}

// -------------------------------------------------------------------

// SyncActionValue_MuteAction

// optional bool muted = 1;
inline bool SyncActionValue_MuteAction::_internal_has_muted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_MuteAction::has_muted() const {
  return _internal_has_muted();
}
inline void SyncActionValue_MuteAction::clear_muted() {
  _impl_.muted_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SyncActionValue_MuteAction::_internal_muted() const {
  return _impl_.muted_;
}
inline bool SyncActionValue_MuteAction::muted() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muted)
  return _internal_muted();
}
inline void SyncActionValue_MuteAction::_internal_set_muted(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.muted_ = value;
}
inline void SyncActionValue_MuteAction::set_muted(bool value) {
  _internal_set_muted(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muted)
}

// optional int64 muteEndTimestamp = 2;
inline bool SyncActionValue_MuteAction::_internal_has_muteendtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_MuteAction::has_muteendtimestamp() const {
  return _internal_has_muteendtimestamp();
}
inline void SyncActionValue_MuteAction::clear_muteendtimestamp() {
  _impl_.muteendtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SyncActionValue_MuteAction::_internal_muteendtimestamp() const {
  return _impl_.muteendtimestamp_;
}
inline int64_t SyncActionValue_MuteAction::muteendtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.MuteAction.muteEndTimestamp)
  return _internal_muteendtimestamp();
}
inline void SyncActionValue_MuteAction::_internal_set_muteendtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.muteendtimestamp_ = value;
}
inline void SyncActionValue_MuteAction::set_muteendtimestamp(int64_t value) {
  _internal_set_muteendtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.MuteAction.muteEndTimestamp)
}

// -------------------------------------------------------------------

// SyncActionValue_NuxAction

// optional bool acknowledged = 1;
inline bool SyncActionValue_NuxAction::_internal_has_acknowledged() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_NuxAction::has_acknowledged() const {
  return _internal_has_acknowledged();
}
inline void SyncActionValue_NuxAction::clear_acknowledged() {
  _impl_.acknowledged_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_NuxAction::_internal_acknowledged() const {
  return _impl_.acknowledged_;
}
inline bool SyncActionValue_NuxAction::acknowledged() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.NuxAction.acknowledged)
  return _internal_acknowledged();
}
inline void SyncActionValue_NuxAction::_internal_set_acknowledged(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.acknowledged_ = value;
}
inline void SyncActionValue_NuxAction::set_acknowledged(bool value) {
  _internal_set_acknowledged(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.NuxAction.acknowledged)
}

// -------------------------------------------------------------------

// SyncActionValue_PinAction

// optional bool pinned = 1;
inline bool SyncActionValue_PinAction::_internal_has_pinned() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_PinAction::has_pinned() const {
  return _internal_has_pinned();
}
inline void SyncActionValue_PinAction::clear_pinned() {
  _impl_.pinned_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_PinAction::_internal_pinned() const {
  return _impl_.pinned_;
}
inline bool SyncActionValue_PinAction::pinned() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PinAction.pinned)
  return _internal_pinned();
}
inline void SyncActionValue_PinAction::_internal_set_pinned(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pinned_ = value;
}
inline void SyncActionValue_PinAction::set_pinned(bool value) {
  _internal_set_pinned(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PinAction.pinned)
}

// -------------------------------------------------------------------

// SyncActionValue_PrimaryFeature

// repeated string flags = 1;
inline int SyncActionValue_PrimaryFeature::_internal_flags_size() const {
  return _impl_.flags_.size();
}
inline int SyncActionValue_PrimaryFeature::flags_size() const {
  return _internal_flags_size();
}
inline void SyncActionValue_PrimaryFeature::clear_flags() {
  _impl_.flags_.Clear();
}
inline std::string* SyncActionValue_PrimaryFeature::add_flags() {
  std::string* _s = _internal_add_flags();
  // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.PrimaryFeature.flags)
  return _s;
}
inline const std::string& SyncActionValue_PrimaryFeature::_internal_flags(int index) const {
  return _impl_.flags_.Get(index);
}
inline const std::string& SyncActionValue_PrimaryFeature::flags(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryFeature.flags)
  return _internal_flags(index);
}
inline std::string* SyncActionValue_PrimaryFeature::mutable_flags(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryFeature.flags)
  return _impl_.flags_.Mutable(index);
}
inline void SyncActionValue_PrimaryFeature::set_flags(int index, const std::string& value) {
  _impl_.flags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::set_flags(int index, std::string&& value) {
  _impl_.flags_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.flags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::set_flags(int index, const char* value, size_t size) {
  _impl_.flags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.PrimaryFeature.flags)
}
inline std::string* SyncActionValue_PrimaryFeature::_internal_add_flags() {
  return _impl_.flags_.Add();
}
inline void SyncActionValue_PrimaryFeature::add_flags(const std::string& value) {
  _impl_.flags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::add_flags(std::string&& value) {
  _impl_.flags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::add_flags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.flags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.PrimaryFeature.flags)
}
inline void SyncActionValue_PrimaryFeature::add_flags(const char* value, size_t size) {
  _impl_.flags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.PrimaryFeature.flags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SyncActionValue_PrimaryFeature::flags() const {
  // @@protoc_insertion_point(field_list:proto.SyncActionValue.PrimaryFeature.flags)
  return _impl_.flags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SyncActionValue_PrimaryFeature::mutable_flags() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.PrimaryFeature.flags)
  return &_impl_.flags_;
}

// -------------------------------------------------------------------

// SyncActionValue_PrimaryVersionAction

// optional string version = 1;
inline bool SyncActionValue_PrimaryVersionAction::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_PrimaryVersionAction::has_version() const {
  return _internal_has_version();
}
inline void SyncActionValue_PrimaryVersionAction::clear_version() {
  _impl_.version_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_PrimaryVersionAction::version() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PrimaryVersionAction.version)
  return _internal_version();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_PrimaryVersionAction::set_version(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PrimaryVersionAction.version)
}
inline std::string* SyncActionValue_PrimaryVersionAction::mutable_version() {
  std::string* _s = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PrimaryVersionAction.version)
  return _s;
}
inline const std::string& SyncActionValue_PrimaryVersionAction::_internal_version() const {
  return _impl_.version_.Get();
}
inline void SyncActionValue_PrimaryVersionAction::_internal_set_version(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_PrimaryVersionAction::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.version_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_PrimaryVersionAction::release_version() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.PrimaryVersionAction.version)
  if (!_internal_has_version()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.version_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_PrimaryVersionAction::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.version_.SetAllocated(version, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.version_.IsDefault()) {
    _impl_.version_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.PrimaryVersionAction.version)
}

// -------------------------------------------------------------------

// SyncActionValue_PushNameSetting

// optional string name = 1;
inline bool SyncActionValue_PushNameSetting::_internal_has_name() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_PushNameSetting::has_name() const {
  return _internal_has_name();
}
inline void SyncActionValue_PushNameSetting::clear_name() {
  _impl_.name_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_PushNameSetting::name() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.PushNameSetting.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_PushNameSetting::set_name(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.PushNameSetting.name)
}
inline std::string* SyncActionValue_PushNameSetting::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.PushNameSetting.name)
  return _s;
}
inline const std::string& SyncActionValue_PushNameSetting::_internal_name() const {
  return _impl_.name_.Get();
}
inline void SyncActionValue_PushNameSetting::_internal_set_name(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.name_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_PushNameSetting::_internal_mutable_name() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.name_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_PushNameSetting::release_name() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.PushNameSetting.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 SyncActionValue_PushNameSetting::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.SyncActionValue.PushNameSetting.name)
}

// -------------------------------------------------------------------

// SyncActionValue_QuickReplyAction

// optional string shortcut = 1;
inline bool SyncActionValue_QuickReplyAction::_internal_has_shortcut() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_QuickReplyAction::has_shortcut() const {
  return _internal_has_shortcut();
}
inline void SyncActionValue_QuickReplyAction::clear_shortcut() {
  _impl_.shortcut_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_QuickReplyAction::shortcut() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.shortcut)
  return _internal_shortcut();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_QuickReplyAction::set_shortcut(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.shortcut_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.shortcut)
}
inline std::string* SyncActionValue_QuickReplyAction::mutable_shortcut() {
  std::string* _s = _internal_mutable_shortcut();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.shortcut)
  return _s;
}
inline const std::string& SyncActionValue_QuickReplyAction::_internal_shortcut() const {
  return _impl_.shortcut_.Get();
}
inline void SyncActionValue_QuickReplyAction::_internal_set_shortcut(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.shortcut_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_shortcut() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.shortcut_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_QuickReplyAction::release_shortcut() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.shortcut)
  if (!_internal_has_shortcut()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.shortcut_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.shortcut_.IsDefault()) {
    _impl_.shortcut_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_QuickReplyAction::set_allocated_shortcut(std::string* shortcut) {
  if (shortcut != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.shortcut_.SetAllocated(shortcut, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.shortcut_.IsDefault()) {
    _impl_.shortcut_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.shortcut)
}

// optional string message = 2;
inline bool SyncActionValue_QuickReplyAction::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_QuickReplyAction::has_message() const {
  return _internal_has_message();
}
inline void SyncActionValue_QuickReplyAction::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SyncActionValue_QuickReplyAction::message() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_QuickReplyAction::set_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.message)
}
inline std::string* SyncActionValue_QuickReplyAction::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.message)
  return _s;
}
inline const std::string& SyncActionValue_QuickReplyAction::_internal_message() const {
  return _impl_.message_.Get();
}
inline void SyncActionValue_QuickReplyAction::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_QuickReplyAction::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_QuickReplyAction::release_message() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.QuickReplyAction.message)
  if (!_internal_has_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_QuickReplyAction::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.QuickReplyAction.message)
}

// repeated string keywords = 3;
inline int SyncActionValue_QuickReplyAction::_internal_keywords_size() const {
  return _impl_.keywords_.size();
}
inline int SyncActionValue_QuickReplyAction::keywords_size() const {
  return _internal_keywords_size();
}
inline void SyncActionValue_QuickReplyAction::clear_keywords() {
  _impl_.keywords_.Clear();
}
inline std::string* SyncActionValue_QuickReplyAction::add_keywords() {
  std::string* _s = _internal_add_keywords();
  // @@protoc_insertion_point(field_add_mutable:proto.SyncActionValue.QuickReplyAction.keywords)
  return _s;
}
inline const std::string& SyncActionValue_QuickReplyAction::_internal_keywords(int index) const {
  return _impl_.keywords_.Get(index);
}
inline const std::string& SyncActionValue_QuickReplyAction::keywords(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.keywords)
  return _internal_keywords(index);
}
inline std::string* SyncActionValue_QuickReplyAction::mutable_keywords(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.QuickReplyAction.keywords)
  return _impl_.keywords_.Mutable(index);
}
inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const std::string& value) {
  _impl_.keywords_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::set_keywords(int index, std::string&& value) {
  _impl_.keywords_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.keywords_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::set_keywords(int index, const char* value, size_t size) {
  _impl_.keywords_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline std::string* SyncActionValue_QuickReplyAction::_internal_add_keywords() {
  return _impl_.keywords_.Add();
}
inline void SyncActionValue_QuickReplyAction::add_keywords(const std::string& value) {
  _impl_.keywords_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::add_keywords(std::string&& value) {
  _impl_.keywords_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.keywords_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline void SyncActionValue_QuickReplyAction::add_keywords(const char* value, size_t size) {
  _impl_.keywords_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.SyncActionValue.QuickReplyAction.keywords)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SyncActionValue_QuickReplyAction::keywords() const {
  // @@protoc_insertion_point(field_list:proto.SyncActionValue.QuickReplyAction.keywords)
  return _impl_.keywords_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SyncActionValue_QuickReplyAction::mutable_keywords() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.QuickReplyAction.keywords)
  return &_impl_.keywords_;
}

// optional int32 count = 4;
inline bool SyncActionValue_QuickReplyAction::_internal_has_count() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SyncActionValue_QuickReplyAction::has_count() const {
  return _internal_has_count();
}
inline void SyncActionValue_QuickReplyAction::clear_count() {
  _impl_.count_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int32_t SyncActionValue_QuickReplyAction::_internal_count() const {
  return _impl_.count_;
}
inline int32_t SyncActionValue_QuickReplyAction::count() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.count)
  return _internal_count();
}
inline void SyncActionValue_QuickReplyAction::_internal_set_count(int32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.count_ = value;
}
inline void SyncActionValue_QuickReplyAction::set_count(int32_t value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.count)
}

// optional bool deleted = 5;
inline bool SyncActionValue_QuickReplyAction::_internal_has_deleted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SyncActionValue_QuickReplyAction::has_deleted() const {
  return _internal_has_deleted();
}
inline void SyncActionValue_QuickReplyAction::clear_deleted() {
  _impl_.deleted_ = false;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline bool SyncActionValue_QuickReplyAction::_internal_deleted() const {
  return _impl_.deleted_;
}
inline bool SyncActionValue_QuickReplyAction::deleted() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.QuickReplyAction.deleted)
  return _internal_deleted();
}
inline void SyncActionValue_QuickReplyAction::_internal_set_deleted(bool value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.deleted_ = value;
}
inline void SyncActionValue_QuickReplyAction::set_deleted(bool value) {
  _internal_set_deleted(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.QuickReplyAction.deleted)
}

// -------------------------------------------------------------------

// SyncActionValue_RecentEmojiWeightsAction

// repeated .proto.RecentEmojiWeight weights = 1;
inline int SyncActionValue_RecentEmojiWeightsAction::_internal_weights_size() const {
  return _impl_.weights_.size();
}
inline int SyncActionValue_RecentEmojiWeightsAction::weights_size() const {
  return _internal_weights_size();
}
inline void SyncActionValue_RecentEmojiWeightsAction::clear_weights() {
  _impl_.weights_.Clear();
}
inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::mutable_weights(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
  return _impl_.weights_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >*
SyncActionValue_RecentEmojiWeightsAction::mutable_weights() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
  return &_impl_.weights_;
}
inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::_internal_weights(int index) const {
  return _impl_.weights_.Get(index);
}
inline const ::proto::RecentEmojiWeight& SyncActionValue_RecentEmojiWeightsAction::weights(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
  return _internal_weights(index);
}
inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::_internal_add_weights() {
  return _impl_.weights_.Add();
}
inline ::proto::RecentEmojiWeight* SyncActionValue_RecentEmojiWeightsAction::add_weights() {
  ::proto::RecentEmojiWeight* _add = _internal_add_weights();
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::RecentEmojiWeight >&
SyncActionValue_RecentEmojiWeightsAction::weights() const {
  // @@protoc_insertion_point(field_list:proto.SyncActionValue.RecentEmojiWeightsAction.weights)
  return _impl_.weights_;
}

// -------------------------------------------------------------------

// SyncActionValue_SecurityNotificationSetting

// optional bool showNotification = 1;
inline bool SyncActionValue_SecurityNotificationSetting::_internal_has_shownotification() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_SecurityNotificationSetting::has_shownotification() const {
  return _internal_has_shownotification();
}
inline void SyncActionValue_SecurityNotificationSetting::clear_shownotification() {
  _impl_.shownotification_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_SecurityNotificationSetting::_internal_shownotification() const {
  return _impl_.shownotification_;
}
inline bool SyncActionValue_SecurityNotificationSetting::shownotification() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SecurityNotificationSetting.showNotification)
  return _internal_shownotification();
}
inline void SyncActionValue_SecurityNotificationSetting::_internal_set_shownotification(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.shownotification_ = value;
}
inline void SyncActionValue_SecurityNotificationSetting::set_shownotification(bool value) {
  _internal_set_shownotification(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SecurityNotificationSetting.showNotification)
}

// -------------------------------------------------------------------

// SyncActionValue_StarAction

// optional bool starred = 1;
inline bool SyncActionValue_StarAction::_internal_has_starred() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_StarAction::has_starred() const {
  return _internal_has_starred();
}
inline void SyncActionValue_StarAction::clear_starred() {
  _impl_.starred_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_StarAction::_internal_starred() const {
  return _impl_.starred_;
}
inline bool SyncActionValue_StarAction::starred() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StarAction.starred)
  return _internal_starred();
}
inline void SyncActionValue_StarAction::_internal_set_starred(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.starred_ = value;
}
inline void SyncActionValue_StarAction::set_starred(bool value) {
  _internal_set_starred(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StarAction.starred)
}

// -------------------------------------------------------------------

// SyncActionValue_StickerAction

// optional string url = 1;
inline bool SyncActionValue_StickerAction::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_url() const {
  return _internal_has_url();
}
inline void SyncActionValue_StickerAction::clear_url() {
  _impl_.url_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncActionValue_StickerAction::url() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.url)
  return _internal_url();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_StickerAction::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:proto.SyncActionValue.StickerAction.url)
}
inline std::string* SyncActionValue_StickerAction::mutable_url() {
  std::string* _s = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.url)
  return _s;
}
inline const std::string& SyncActionValue_StickerAction::_internal_url() const {
  return _impl_.url_.Get();
}
inline void SyncActionValue_StickerAction::_internal_set_url(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.url_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.url_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::release_url() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.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 SyncActionValue_StickerAction::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:proto.SyncActionValue.StickerAction.url)
}

// optional bytes fileEncSha256 = 2;
inline bool SyncActionValue_StickerAction::_internal_has_fileencsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_fileencsha256() const {
  return _internal_has_fileencsha256();
}
inline void SyncActionValue_StickerAction::clear_fileencsha256() {
  _impl_.fileencsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SyncActionValue_StickerAction::fileencsha256() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileEncSha256)
  return _internal_fileencsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_StickerAction::set_fileencsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.fileencsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileEncSha256)
}
inline std::string* SyncActionValue_StickerAction::mutable_fileencsha256() {
  std::string* _s = _internal_mutable_fileencsha256();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.fileEncSha256)
  return _s;
}
inline const std::string& SyncActionValue_StickerAction::_internal_fileencsha256() const {
  return _impl_.fileencsha256_.Get();
}
inline void SyncActionValue_StickerAction::_internal_set_fileencsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.fileencsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::_internal_mutable_fileencsha256() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.fileencsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::release_fileencsha256() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.fileEncSha256)
  if (!_internal_has_fileencsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.fileencsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_StickerAction::set_allocated_fileencsha256(std::string* fileencsha256) {
  if (fileencsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.fileencsha256_.SetAllocated(fileencsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.fileencsha256_.IsDefault()) {
    _impl_.fileencsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.fileEncSha256)
}

// optional bytes mediaKey = 3;
inline bool SyncActionValue_StickerAction::_internal_has_mediakey() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_mediakey() const {
  return _internal_has_mediakey();
}
inline void SyncActionValue_StickerAction::clear_mediakey() {
  _impl_.mediakey_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SyncActionValue_StickerAction::mediakey() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mediaKey)
  return _internal_mediakey();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_StickerAction::set_mediakey(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.mediakey_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mediaKey)
}
inline std::string* SyncActionValue_StickerAction::mutable_mediakey() {
  std::string* _s = _internal_mutable_mediakey();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mediaKey)
  return _s;
}
inline const std::string& SyncActionValue_StickerAction::_internal_mediakey() const {
  return _impl_.mediakey_.Get();
}
inline void SyncActionValue_StickerAction::_internal_set_mediakey(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mediakey_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::_internal_mutable_mediakey() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.mediakey_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::release_mediakey() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mediaKey)
  if (!_internal_has_mediakey()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.mediakey_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_StickerAction::set_allocated_mediakey(std::string* mediakey) {
  if (mediakey != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.mediakey_.SetAllocated(mediakey, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediakey_.IsDefault()) {
    _impl_.mediakey_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mediaKey)
}

// optional string mimetype = 4;
inline bool SyncActionValue_StickerAction::_internal_has_mimetype() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_mimetype() const {
  return _internal_has_mimetype();
}
inline void SyncActionValue_StickerAction::clear_mimetype() {
  _impl_.mimetype_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& SyncActionValue_StickerAction::mimetype() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.mimetype)
  return _internal_mimetype();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_StickerAction::set_mimetype(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.mimetype_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.mimetype)
}
inline std::string* SyncActionValue_StickerAction::mutable_mimetype() {
  std::string* _s = _internal_mutable_mimetype();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.mimetype)
  return _s;
}
inline const std::string& SyncActionValue_StickerAction::_internal_mimetype() const {
  return _impl_.mimetype_.Get();
}
inline void SyncActionValue_StickerAction::_internal_set_mimetype(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.mimetype_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::_internal_mutable_mimetype() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.mimetype_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::release_mimetype() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.mimetype)
  if (!_internal_has_mimetype()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.mimetype_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_StickerAction::set_allocated_mimetype(std::string* mimetype) {
  if (mimetype != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.mimetype_.SetAllocated(mimetype, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mimetype_.IsDefault()) {
    _impl_.mimetype_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.mimetype)
}

// optional uint32 height = 5;
inline bool SyncActionValue_StickerAction::_internal_has_height() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_height() const {
  return _internal_has_height();
}
inline void SyncActionValue_StickerAction::clear_height() {
  _impl_.height_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t SyncActionValue_StickerAction::_internal_height() const {
  return _impl_.height_;
}
inline uint32_t SyncActionValue_StickerAction::height() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.height)
  return _internal_height();
}
inline void SyncActionValue_StickerAction::_internal_set_height(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.height_ = value;
}
inline void SyncActionValue_StickerAction::set_height(uint32_t value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.height)
}

// optional uint32 width = 6;
inline bool SyncActionValue_StickerAction::_internal_has_width() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_width() const {
  return _internal_has_width();
}
inline void SyncActionValue_StickerAction::clear_width() {
  _impl_.width_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t SyncActionValue_StickerAction::_internal_width() const {
  return _impl_.width_;
}
inline uint32_t SyncActionValue_StickerAction::width() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.width)
  return _internal_width();
}
inline void SyncActionValue_StickerAction::_internal_set_width(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.width_ = value;
}
inline void SyncActionValue_StickerAction::set_width(uint32_t value) {
  _internal_set_width(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.width)
}

// optional string directPath = 7;
inline bool SyncActionValue_StickerAction::_internal_has_directpath() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_directpath() const {
  return _internal_has_directpath();
}
inline void SyncActionValue_StickerAction::clear_directpath() {
  _impl_.directpath_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& SyncActionValue_StickerAction::directpath() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.directPath)
  return _internal_directpath();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncActionValue_StickerAction::set_directpath(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.directpath_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.directPath)
}
inline std::string* SyncActionValue_StickerAction::mutable_directpath() {
  std::string* _s = _internal_mutable_directpath();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.StickerAction.directPath)
  return _s;
}
inline const std::string& SyncActionValue_StickerAction::_internal_directpath() const {
  return _impl_.directpath_.Get();
}
inline void SyncActionValue_StickerAction::_internal_set_directpath(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.directpath_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::_internal_mutable_directpath() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.directpath_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncActionValue_StickerAction::release_directpath() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.StickerAction.directPath)
  if (!_internal_has_directpath()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.directpath_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncActionValue_StickerAction::set_allocated_directpath(std::string* directpath) {
  if (directpath != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.directpath_.SetAllocated(directpath, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.directpath_.IsDefault()) {
    _impl_.directpath_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.StickerAction.directPath)
}

// optional uint64 fileLength = 8;
inline bool SyncActionValue_StickerAction::_internal_has_filelength() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_filelength() const {
  return _internal_has_filelength();
}
inline void SyncActionValue_StickerAction::clear_filelength() {
  _impl_.filelength_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint64_t SyncActionValue_StickerAction::_internal_filelength() const {
  return _impl_.filelength_;
}
inline uint64_t SyncActionValue_StickerAction::filelength() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.fileLength)
  return _internal_filelength();
}
inline void SyncActionValue_StickerAction::_internal_set_filelength(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.filelength_ = value;
}
inline void SyncActionValue_StickerAction::set_filelength(uint64_t value) {
  _internal_set_filelength(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.fileLength)
}

// optional bool isFavorite = 9;
inline bool SyncActionValue_StickerAction::_internal_has_isfavorite() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_isfavorite() const {
  return _internal_has_isfavorite();
}
inline void SyncActionValue_StickerAction::clear_isfavorite() {
  _impl_.isfavorite_ = false;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline bool SyncActionValue_StickerAction::_internal_isfavorite() const {
  return _impl_.isfavorite_;
}
inline bool SyncActionValue_StickerAction::isfavorite() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.isFavorite)
  return _internal_isfavorite();
}
inline void SyncActionValue_StickerAction::_internal_set_isfavorite(bool value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.isfavorite_ = value;
}
inline void SyncActionValue_StickerAction::set_isfavorite(bool value) {
  _internal_set_isfavorite(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.isFavorite)
}

// optional uint32 deviceIdHint = 10;
inline bool SyncActionValue_StickerAction::_internal_has_deviceidhint() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SyncActionValue_StickerAction::has_deviceidhint() const {
  return _internal_has_deviceidhint();
}
inline void SyncActionValue_StickerAction::clear_deviceidhint() {
  _impl_.deviceidhint_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t SyncActionValue_StickerAction::_internal_deviceidhint() const {
  return _impl_.deviceidhint_;
}
inline uint32_t SyncActionValue_StickerAction::deviceidhint() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.StickerAction.deviceIdHint)
  return _internal_deviceidhint();
}
inline void SyncActionValue_StickerAction::_internal_set_deviceidhint(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.deviceidhint_ = value;
}
inline void SyncActionValue_StickerAction::set_deviceidhint(uint32_t value) {
  _internal_set_deviceidhint(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.StickerAction.deviceIdHint)
}

// -------------------------------------------------------------------

// SyncActionValue_SubscriptionAction

// optional bool isDeactivated = 1;
inline bool SyncActionValue_SubscriptionAction::_internal_has_isdeactivated() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_SubscriptionAction::has_isdeactivated() const {
  return _internal_has_isdeactivated();
}
inline void SyncActionValue_SubscriptionAction::clear_isdeactivated() {
  _impl_.isdeactivated_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool SyncActionValue_SubscriptionAction::_internal_isdeactivated() const {
  return _impl_.isdeactivated_;
}
inline bool SyncActionValue_SubscriptionAction::isdeactivated() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isDeactivated)
  return _internal_isdeactivated();
}
inline void SyncActionValue_SubscriptionAction::_internal_set_isdeactivated(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.isdeactivated_ = value;
}
inline void SyncActionValue_SubscriptionAction::set_isdeactivated(bool value) {
  _internal_set_isdeactivated(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isDeactivated)
}

// optional bool isAutoRenewing = 2;
inline bool SyncActionValue_SubscriptionAction::_internal_has_isautorenewing() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SyncActionValue_SubscriptionAction::has_isautorenewing() const {
  return _internal_has_isautorenewing();
}
inline void SyncActionValue_SubscriptionAction::clear_isautorenewing() {
  _impl_.isautorenewing_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool SyncActionValue_SubscriptionAction::_internal_isautorenewing() const {
  return _impl_.isautorenewing_;
}
inline bool SyncActionValue_SubscriptionAction::isautorenewing() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.isAutoRenewing)
  return _internal_isautorenewing();
}
inline void SyncActionValue_SubscriptionAction::_internal_set_isautorenewing(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.isautorenewing_ = value;
}
inline void SyncActionValue_SubscriptionAction::set_isautorenewing(bool value) {
  _internal_set_isautorenewing(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.isAutoRenewing)
}

// optional int64 expirationDate = 3;
inline bool SyncActionValue_SubscriptionAction::_internal_has_expirationdate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_SubscriptionAction::has_expirationdate() const {
  return _internal_has_expirationdate();
}
inline void SyncActionValue_SubscriptionAction::clear_expirationdate() {
  _impl_.expirationdate_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SyncActionValue_SubscriptionAction::_internal_expirationdate() const {
  return _impl_.expirationdate_;
}
inline int64_t SyncActionValue_SubscriptionAction::expirationdate() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SubscriptionAction.expirationDate)
  return _internal_expirationdate();
}
inline void SyncActionValue_SubscriptionAction::_internal_set_expirationdate(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.expirationdate_ = value;
}
inline void SyncActionValue_SubscriptionAction::set_expirationdate(int64_t value) {
  _internal_set_expirationdate(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SubscriptionAction.expirationDate)
}

// -------------------------------------------------------------------

// SyncActionValue_SyncActionMessageRange

// optional int64 lastMessageTimestamp = 1;
inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastmessagetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_SyncActionMessageRange::has_lastmessagetimestamp() const {
  return _internal_has_lastmessagetimestamp();
}
inline void SyncActionValue_SyncActionMessageRange::clear_lastmessagetimestamp() {
  _impl_.lastmessagetimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastmessagetimestamp() const {
  return _impl_.lastmessagetimestamp_;
}
inline int64_t SyncActionValue_SyncActionMessageRange::lastmessagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp)
  return _internal_lastmessagetimestamp();
}
inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastmessagetimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.lastmessagetimestamp_ = value;
}
inline void SyncActionValue_SyncActionMessageRange::set_lastmessagetimestamp(int64_t value) {
  _internal_set_lastmessagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastMessageTimestamp)
}

// optional int64 lastSystemMessageTimestamp = 2;
inline bool SyncActionValue_SyncActionMessageRange::_internal_has_lastsystemmessagetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_SyncActionMessageRange::has_lastsystemmessagetimestamp() const {
  return _internal_has_lastsystemmessagetimestamp();
}
inline void SyncActionValue_SyncActionMessageRange::clear_lastsystemmessagetimestamp() {
  _impl_.lastsystemmessagetimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t SyncActionValue_SyncActionMessageRange::_internal_lastsystemmessagetimestamp() const {
  return _impl_.lastsystemmessagetimestamp_;
}
inline int64_t SyncActionValue_SyncActionMessageRange::lastsystemmessagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp)
  return _internal_lastsystemmessagetimestamp();
}
inline void SyncActionValue_SyncActionMessageRange::_internal_set_lastsystemmessagetimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.lastsystemmessagetimestamp_ = value;
}
inline void SyncActionValue_SyncActionMessageRange::set_lastsystemmessagetimestamp(int64_t value) {
  _internal_set_lastsystemmessagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessageRange.lastSystemMessageTimestamp)
}

// repeated .proto.SyncActionValue.SyncActionMessage messages = 3;
inline int SyncActionValue_SyncActionMessageRange::_internal_messages_size() const {
  return _impl_.messages_.size();
}
inline int SyncActionValue_SyncActionMessageRange::messages_size() const {
  return _internal_messages_size();
}
inline void SyncActionValue_SyncActionMessageRange::clear_messages() {
  _impl_.messages_.Clear();
}
inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::mutable_messages(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessageRange.messages)
  return _impl_.messages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >*
SyncActionValue_SyncActionMessageRange::mutable_messages() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncActionValue.SyncActionMessageRange.messages)
  return &_impl_.messages_;
}
inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::_internal_messages(int index) const {
  return _impl_.messages_.Get(index);
}
inline const ::proto::SyncActionValue_SyncActionMessage& SyncActionValue_SyncActionMessageRange::messages(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessageRange.messages)
  return _internal_messages(index);
}
inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::_internal_add_messages() {
  return _impl_.messages_.Add();
}
inline ::proto::SyncActionValue_SyncActionMessage* SyncActionValue_SyncActionMessageRange::add_messages() {
  ::proto::SyncActionValue_SyncActionMessage* _add = _internal_add_messages();
  // @@protoc_insertion_point(field_add:proto.SyncActionValue.SyncActionMessageRange.messages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncActionValue_SyncActionMessage >&
SyncActionValue_SyncActionMessageRange::messages() const {
  // @@protoc_insertion_point(field_list:proto.SyncActionValue.SyncActionMessageRange.messages)
  return _impl_.messages_;
}

// -------------------------------------------------------------------

// SyncActionValue_SyncActionMessage

// optional .proto.MessageKey key = 1;
inline bool SyncActionValue_SyncActionMessage::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool SyncActionValue_SyncActionMessage::has_key() const {
  return _internal_has_key();
}
inline void SyncActionValue_SyncActionMessage::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& SyncActionValue_SyncActionMessage::key() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.key)
  return _internal_key();
}
inline void SyncActionValue_SyncActionMessage::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.SyncActionMessage.key)
}
inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::release_key() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* SyncActionValue_SyncActionMessage::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.SyncActionMessage.key)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* SyncActionValue_SyncActionMessage::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.SyncActionMessage.key)
  return _msg;
}
inline void SyncActionValue_SyncActionMessage::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.SyncActionMessage.key)
}

// optional int64 timestamp = 2;
inline bool SyncActionValue_SyncActionMessage::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncActionValue_SyncActionMessage::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void SyncActionValue_SyncActionMessage::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t SyncActionValue_SyncActionMessage::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t SyncActionValue_SyncActionMessage::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.SyncActionMessage.timestamp)
  return _internal_timestamp();
}
inline void SyncActionValue_SyncActionMessage::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.timestamp_ = value;
}
inline void SyncActionValue_SyncActionMessage::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.SyncActionMessage.timestamp)
}

// -------------------------------------------------------------------

// SyncActionValue_TimeFormatAction

// optional bool isTwentyFourHourFormatEnabled = 1;
inline bool SyncActionValue_TimeFormatAction::_internal_has_istwentyfourhourformatenabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_TimeFormatAction::has_istwentyfourhourformatenabled() const {
  return _internal_has_istwentyfourhourformatenabled();
}
inline void SyncActionValue_TimeFormatAction::clear_istwentyfourhourformatenabled() {
  _impl_.istwentyfourhourformatenabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_TimeFormatAction::_internal_istwentyfourhourformatenabled() const {
  return _impl_.istwentyfourhourformatenabled_;
}
inline bool SyncActionValue_TimeFormatAction::istwentyfourhourformatenabled() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled)
  return _internal_istwentyfourhourformatenabled();
}
inline void SyncActionValue_TimeFormatAction::_internal_set_istwentyfourhourformatenabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.istwentyfourhourformatenabled_ = value;
}
inline void SyncActionValue_TimeFormatAction::set_istwentyfourhourformatenabled(bool value) {
  _internal_set_istwentyfourhourformatenabled(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.TimeFormatAction.isTwentyFourHourFormatEnabled)
}

// -------------------------------------------------------------------

// SyncActionValue_UnarchiveChatsSetting

// optional bool unarchiveChats = 1;
inline bool SyncActionValue_UnarchiveChatsSetting::_internal_has_unarchivechats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_UnarchiveChatsSetting::has_unarchivechats() const {
  return _internal_has_unarchivechats();
}
inline void SyncActionValue_UnarchiveChatsSetting::clear_unarchivechats() {
  _impl_.unarchivechats_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_UnarchiveChatsSetting::_internal_unarchivechats() const {
  return _impl_.unarchivechats_;
}
inline bool SyncActionValue_UnarchiveChatsSetting::unarchivechats() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats)
  return _internal_unarchivechats();
}
inline void SyncActionValue_UnarchiveChatsSetting::_internal_set_unarchivechats(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.unarchivechats_ = value;
}
inline void SyncActionValue_UnarchiveChatsSetting::set_unarchivechats(bool value) {
  _internal_set_unarchivechats(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.UnarchiveChatsSetting.unarchiveChats)
}

// -------------------------------------------------------------------

// SyncActionValue_UserStatusMuteAction

// optional bool muted = 1;
inline bool SyncActionValue_UserStatusMuteAction::_internal_has_muted() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncActionValue_UserStatusMuteAction::has_muted() const {
  return _internal_has_muted();
}
inline void SyncActionValue_UserStatusMuteAction::clear_muted() {
  _impl_.muted_ = false;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline bool SyncActionValue_UserStatusMuteAction::_internal_muted() const {
  return _impl_.muted_;
}
inline bool SyncActionValue_UserStatusMuteAction::muted() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.UserStatusMuteAction.muted)
  return _internal_muted();
}
inline void SyncActionValue_UserStatusMuteAction::_internal_set_muted(bool value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.muted_ = value;
}
inline void SyncActionValue_UserStatusMuteAction::set_muted(bool value) {
  _internal_set_muted(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.UserStatusMuteAction.muted)
}

// -------------------------------------------------------------------

// SyncActionValue

// optional int64 timestamp = 1;
inline bool SyncActionValue::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool SyncActionValue::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void SyncActionValue::clear_timestamp() {
  _impl_.timestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline int64_t SyncActionValue::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline int64_t SyncActionValue::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.timestamp)
  return _internal_timestamp();
}
inline void SyncActionValue::_internal_set_timestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.timestamp_ = value;
}
inline void SyncActionValue::set_timestamp(int64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.SyncActionValue.timestamp)
}

// optional .proto.SyncActionValue.StarAction starAction = 2;
inline bool SyncActionValue::_internal_has_staraction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.staraction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_staraction() const {
  return _internal_has_staraction();
}
inline void SyncActionValue::clear_staraction() {
  if (_impl_.staraction_ != nullptr) _impl_.staraction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncActionValue_StarAction& SyncActionValue::_internal_staraction() const {
  const ::proto::SyncActionValue_StarAction* p = _impl_.staraction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_StarAction&>(
      ::proto::_SyncActionValue_StarAction_default_instance_);
}
inline const ::proto::SyncActionValue_StarAction& SyncActionValue::staraction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.starAction)
  return _internal_staraction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_staraction(
    ::proto::SyncActionValue_StarAction* staraction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.staraction_);
  }
  _impl_.staraction_ = staraction;
  if (staraction) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.starAction)
}
inline ::proto::SyncActionValue_StarAction* SyncActionValue::release_staraction() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_;
  _impl_.staraction_ = 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 ::proto::SyncActionValue_StarAction* SyncActionValue::unsafe_arena_release_staraction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.starAction)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncActionValue_StarAction* temp = _impl_.staraction_;
  _impl_.staraction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_StarAction* SyncActionValue::_internal_mutable_staraction() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.staraction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_StarAction>(GetArenaForAllocation());
    _impl_.staraction_ = p;
  }
  return _impl_.staraction_;
}
inline ::proto::SyncActionValue_StarAction* SyncActionValue::mutable_staraction() {
  ::proto::SyncActionValue_StarAction* _msg = _internal_mutable_staraction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.starAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_staraction(::proto::SyncActionValue_StarAction* staraction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.staraction_;
  }
  if (staraction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(staraction);
    if (message_arena != submessage_arena) {
      staraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, staraction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.staraction_ = staraction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.starAction)
}

// optional .proto.SyncActionValue.ContactAction contactAction = 3;
inline bool SyncActionValue::_internal_has_contactaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.contactaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_contactaction() const {
  return _internal_has_contactaction();
}
inline void SyncActionValue::clear_contactaction() {
  if (_impl_.contactaction_ != nullptr) _impl_.contactaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::_internal_contactaction() const {
  const ::proto::SyncActionValue_ContactAction* p = _impl_.contactaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ContactAction&>(
      ::proto::_SyncActionValue_ContactAction_default_instance_);
}
inline const ::proto::SyncActionValue_ContactAction& SyncActionValue::contactaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.contactAction)
  return _internal_contactaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_contactaction(
    ::proto::SyncActionValue_ContactAction* contactaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.contactaction_);
  }
  _impl_.contactaction_ = contactaction;
  if (contactaction) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.contactAction)
}
inline ::proto::SyncActionValue_ContactAction* SyncActionValue::release_contactaction() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_;
  _impl_.contactaction_ = 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 ::proto::SyncActionValue_ContactAction* SyncActionValue::unsafe_arena_release_contactaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.contactAction)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncActionValue_ContactAction* temp = _impl_.contactaction_;
  _impl_.contactaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_ContactAction* SyncActionValue::_internal_mutable_contactaction() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.contactaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ContactAction>(GetArenaForAllocation());
    _impl_.contactaction_ = p;
  }
  return _impl_.contactaction_;
}
inline ::proto::SyncActionValue_ContactAction* SyncActionValue::mutable_contactaction() {
  ::proto::SyncActionValue_ContactAction* _msg = _internal_mutable_contactaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.contactAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_contactaction(::proto::SyncActionValue_ContactAction* contactaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.contactaction_;
  }
  if (contactaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(contactaction);
    if (message_arena != submessage_arena) {
      contactaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, contactaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.contactaction_ = contactaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.contactAction)
}

// optional .proto.SyncActionValue.MuteAction muteAction = 4;
inline bool SyncActionValue::_internal_has_muteaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.muteaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_muteaction() const {
  return _internal_has_muteaction();
}
inline void SyncActionValue::clear_muteaction() {
  if (_impl_.muteaction_ != nullptr) _impl_.muteaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::_internal_muteaction() const {
  const ::proto::SyncActionValue_MuteAction* p = _impl_.muteaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_MuteAction&>(
      ::proto::_SyncActionValue_MuteAction_default_instance_);
}
inline const ::proto::SyncActionValue_MuteAction& SyncActionValue::muteaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.muteAction)
  return _internal_muteaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_muteaction(
    ::proto::SyncActionValue_MuteAction* muteaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.muteaction_);
  }
  _impl_.muteaction_ = muteaction;
  if (muteaction) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.muteAction)
}
inline ::proto::SyncActionValue_MuteAction* SyncActionValue::release_muteaction() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_;
  _impl_.muteaction_ = 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 ::proto::SyncActionValue_MuteAction* SyncActionValue::unsafe_arena_release_muteaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.muteAction)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncActionValue_MuteAction* temp = _impl_.muteaction_;
  _impl_.muteaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_MuteAction* SyncActionValue::_internal_mutable_muteaction() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.muteaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_MuteAction>(GetArenaForAllocation());
    _impl_.muteaction_ = p;
  }
  return _impl_.muteaction_;
}
inline ::proto::SyncActionValue_MuteAction* SyncActionValue::mutable_muteaction() {
  ::proto::SyncActionValue_MuteAction* _msg = _internal_mutable_muteaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.muteAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_muteaction(::proto::SyncActionValue_MuteAction* muteaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.muteaction_;
  }
  if (muteaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(muteaction);
    if (message_arena != submessage_arena) {
      muteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, muteaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.muteaction_ = muteaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.muteAction)
}

// optional .proto.SyncActionValue.PinAction pinAction = 5;
inline bool SyncActionValue::_internal_has_pinaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pinaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_pinaction() const {
  return _internal_has_pinaction();
}
inline void SyncActionValue::clear_pinaction() {
  if (_impl_.pinaction_ != nullptr) _impl_.pinaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::SyncActionValue_PinAction& SyncActionValue::_internal_pinaction() const {
  const ::proto::SyncActionValue_PinAction* p = _impl_.pinaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PinAction&>(
      ::proto::_SyncActionValue_PinAction_default_instance_);
}
inline const ::proto::SyncActionValue_PinAction& SyncActionValue::pinaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.pinAction)
  return _internal_pinaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_pinaction(
    ::proto::SyncActionValue_PinAction* pinaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pinaction_);
  }
  _impl_.pinaction_ = pinaction;
  if (pinaction) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pinAction)
}
inline ::proto::SyncActionValue_PinAction* SyncActionValue::release_pinaction() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_;
  _impl_.pinaction_ = 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 ::proto::SyncActionValue_PinAction* SyncActionValue::unsafe_arena_release_pinaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.pinAction)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::SyncActionValue_PinAction* temp = _impl_.pinaction_;
  _impl_.pinaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_PinAction* SyncActionValue::_internal_mutable_pinaction() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.pinaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PinAction>(GetArenaForAllocation());
    _impl_.pinaction_ = p;
  }
  return _impl_.pinaction_;
}
inline ::proto::SyncActionValue_PinAction* SyncActionValue::mutable_pinaction() {
  ::proto::SyncActionValue_PinAction* _msg = _internal_mutable_pinaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pinAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_pinaction(::proto::SyncActionValue_PinAction* pinaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pinaction_;
  }
  if (pinaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pinaction);
    if (message_arena != submessage_arena) {
      pinaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pinaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.pinaction_ = pinaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pinAction)
}

// optional .proto.SyncActionValue.SecurityNotificationSetting securityNotificationSetting = 6;
inline bool SyncActionValue::_internal_has_securitynotificationsetting() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.securitynotificationsetting_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_securitynotificationsetting() const {
  return _internal_has_securitynotificationsetting();
}
inline void SyncActionValue::clear_securitynotificationsetting() {
  if (_impl_.securitynotificationsetting_ != nullptr) _impl_.securitynotificationsetting_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::_internal_securitynotificationsetting() const {
  const ::proto::SyncActionValue_SecurityNotificationSetting* p = _impl_.securitynotificationsetting_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SecurityNotificationSetting&>(
      ::proto::_SyncActionValue_SecurityNotificationSetting_default_instance_);
}
inline const ::proto::SyncActionValue_SecurityNotificationSetting& SyncActionValue::securitynotificationsetting() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.securityNotificationSetting)
  return _internal_securitynotificationsetting();
}
inline void SyncActionValue::unsafe_arena_set_allocated_securitynotificationsetting(
    ::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.securitynotificationsetting_);
  }
  _impl_.securitynotificationsetting_ = securitynotificationsetting;
  if (securitynotificationsetting) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.securityNotificationSetting)
}
inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::release_securitynotificationsetting() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_;
  _impl_.securitynotificationsetting_ = 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 ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::unsafe_arena_release_securitynotificationsetting() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.securityNotificationSetting)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::SyncActionValue_SecurityNotificationSetting* temp = _impl_.securitynotificationsetting_;
  _impl_.securitynotificationsetting_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::_internal_mutable_securitynotificationsetting() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.securitynotificationsetting_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SecurityNotificationSetting>(GetArenaForAllocation());
    _impl_.securitynotificationsetting_ = p;
  }
  return _impl_.securitynotificationsetting_;
}
inline ::proto::SyncActionValue_SecurityNotificationSetting* SyncActionValue::mutable_securitynotificationsetting() {
  ::proto::SyncActionValue_SecurityNotificationSetting* _msg = _internal_mutable_securitynotificationsetting();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.securityNotificationSetting)
  return _msg;
}
inline void SyncActionValue::set_allocated_securitynotificationsetting(::proto::SyncActionValue_SecurityNotificationSetting* securitynotificationsetting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.securitynotificationsetting_;
  }
  if (securitynotificationsetting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(securitynotificationsetting);
    if (message_arena != submessage_arena) {
      securitynotificationsetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, securitynotificationsetting, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.securitynotificationsetting_ = securitynotificationsetting;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.securityNotificationSetting)
}

// optional .proto.SyncActionValue.PushNameSetting pushNameSetting = 7;
inline bool SyncActionValue::_internal_has_pushnamesetting() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.pushnamesetting_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_pushnamesetting() const {
  return _internal_has_pushnamesetting();
}
inline void SyncActionValue::clear_pushnamesetting() {
  if (_impl_.pushnamesetting_ != nullptr) _impl_.pushnamesetting_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::_internal_pushnamesetting() const {
  const ::proto::SyncActionValue_PushNameSetting* p = _impl_.pushnamesetting_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PushNameSetting&>(
      ::proto::_SyncActionValue_PushNameSetting_default_instance_);
}
inline const ::proto::SyncActionValue_PushNameSetting& SyncActionValue::pushnamesetting() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.pushNameSetting)
  return _internal_pushnamesetting();
}
inline void SyncActionValue::unsafe_arena_set_allocated_pushnamesetting(
    ::proto::SyncActionValue_PushNameSetting* pushnamesetting) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pushnamesetting_);
  }
  _impl_.pushnamesetting_ = pushnamesetting;
  if (pushnamesetting) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.pushNameSetting)
}
inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::release_pushnamesetting() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_;
  _impl_.pushnamesetting_ = 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 ::proto::SyncActionValue_PushNameSetting* SyncActionValue::unsafe_arena_release_pushnamesetting() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.pushNameSetting)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::SyncActionValue_PushNameSetting* temp = _impl_.pushnamesetting_;
  _impl_.pushnamesetting_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::_internal_mutable_pushnamesetting() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.pushnamesetting_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PushNameSetting>(GetArenaForAllocation());
    _impl_.pushnamesetting_ = p;
  }
  return _impl_.pushnamesetting_;
}
inline ::proto::SyncActionValue_PushNameSetting* SyncActionValue::mutable_pushnamesetting() {
  ::proto::SyncActionValue_PushNameSetting* _msg = _internal_mutable_pushnamesetting();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.pushNameSetting)
  return _msg;
}
inline void SyncActionValue::set_allocated_pushnamesetting(::proto::SyncActionValue_PushNameSetting* pushnamesetting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.pushnamesetting_;
  }
  if (pushnamesetting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(pushnamesetting);
    if (message_arena != submessage_arena) {
      pushnamesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, pushnamesetting, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.pushnamesetting_ = pushnamesetting;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.pushNameSetting)
}

// optional .proto.SyncActionValue.QuickReplyAction quickReplyAction = 8;
inline bool SyncActionValue::_internal_has_quickreplyaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quickreplyaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_quickreplyaction() const {
  return _internal_has_quickreplyaction();
}
inline void SyncActionValue::clear_quickreplyaction() {
  if (_impl_.quickreplyaction_ != nullptr) _impl_.quickreplyaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::_internal_quickreplyaction() const {
  const ::proto::SyncActionValue_QuickReplyAction* p = _impl_.quickreplyaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_QuickReplyAction&>(
      ::proto::_SyncActionValue_QuickReplyAction_default_instance_);
}
inline const ::proto::SyncActionValue_QuickReplyAction& SyncActionValue::quickreplyaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.quickReplyAction)
  return _internal_quickreplyaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_quickreplyaction(
    ::proto::SyncActionValue_QuickReplyAction* quickreplyaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quickreplyaction_);
  }
  _impl_.quickreplyaction_ = quickreplyaction;
  if (quickreplyaction) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.quickReplyAction)
}
inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::release_quickreplyaction() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_;
  _impl_.quickreplyaction_ = 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 ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::unsafe_arena_release_quickreplyaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.quickReplyAction)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::proto::SyncActionValue_QuickReplyAction* temp = _impl_.quickreplyaction_;
  _impl_.quickreplyaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::_internal_mutable_quickreplyaction() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.quickreplyaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_QuickReplyAction>(GetArenaForAllocation());
    _impl_.quickreplyaction_ = p;
  }
  return _impl_.quickreplyaction_;
}
inline ::proto::SyncActionValue_QuickReplyAction* SyncActionValue::mutable_quickreplyaction() {
  ::proto::SyncActionValue_QuickReplyAction* _msg = _internal_mutable_quickreplyaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.quickReplyAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_quickreplyaction(::proto::SyncActionValue_QuickReplyAction* quickreplyaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quickreplyaction_;
  }
  if (quickreplyaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quickreplyaction);
    if (message_arena != submessage_arena) {
      quickreplyaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quickreplyaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.quickreplyaction_ = quickreplyaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.quickReplyAction)
}

// optional .proto.SyncActionValue.RecentEmojiWeightsAction recentEmojiWeightsAction = 11;
inline bool SyncActionValue::_internal_has_recentemojiweightsaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.recentemojiweightsaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_recentemojiweightsaction() const {
  return _internal_has_recentemojiweightsaction();
}
inline void SyncActionValue::clear_recentemojiweightsaction() {
  if (_impl_.recentemojiweightsaction_ != nullptr) _impl_.recentemojiweightsaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::_internal_recentemojiweightsaction() const {
  const ::proto::SyncActionValue_RecentEmojiWeightsAction* p = _impl_.recentemojiweightsaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_RecentEmojiWeightsAction&>(
      ::proto::_SyncActionValue_RecentEmojiWeightsAction_default_instance_);
}
inline const ::proto::SyncActionValue_RecentEmojiWeightsAction& SyncActionValue::recentemojiweightsaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.recentEmojiWeightsAction)
  return _internal_recentemojiweightsaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_recentemojiweightsaction(
    ::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.recentemojiweightsaction_);
  }
  _impl_.recentemojiweightsaction_ = recentemojiweightsaction;
  if (recentemojiweightsaction) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction)
}
inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::release_recentemojiweightsaction() {
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_;
  _impl_.recentemojiweightsaction_ = 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 ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::unsafe_arena_release_recentemojiweightsaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.recentEmojiWeightsAction)
  _impl_._has_bits_[0] &= ~0x00000080u;
  ::proto::SyncActionValue_RecentEmojiWeightsAction* temp = _impl_.recentemojiweightsaction_;
  _impl_.recentemojiweightsaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::_internal_mutable_recentemojiweightsaction() {
  _impl_._has_bits_[0] |= 0x00000080u;
  if (_impl_.recentemojiweightsaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_RecentEmojiWeightsAction>(GetArenaForAllocation());
    _impl_.recentemojiweightsaction_ = p;
  }
  return _impl_.recentemojiweightsaction_;
}
inline ::proto::SyncActionValue_RecentEmojiWeightsAction* SyncActionValue::mutable_recentemojiweightsaction() {
  ::proto::SyncActionValue_RecentEmojiWeightsAction* _msg = _internal_mutable_recentemojiweightsaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.recentEmojiWeightsAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_recentemojiweightsaction(::proto::SyncActionValue_RecentEmojiWeightsAction* recentemojiweightsaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.recentemojiweightsaction_;
  }
  if (recentemojiweightsaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(recentemojiweightsaction);
    if (message_arena != submessage_arena) {
      recentemojiweightsaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, recentemojiweightsaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.recentemojiweightsaction_ = recentemojiweightsaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.recentEmojiWeightsAction)
}

// optional .proto.SyncActionValue.LabelEditAction labelEditAction = 14;
inline bool SyncActionValue::_internal_has_labeleditaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.labeleditaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_labeleditaction() const {
  return _internal_has_labeleditaction();
}
inline void SyncActionValue::clear_labeleditaction() {
  if (_impl_.labeleditaction_ != nullptr) _impl_.labeleditaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::_internal_labeleditaction() const {
  const ::proto::SyncActionValue_LabelEditAction* p = _impl_.labeleditaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LabelEditAction&>(
      ::proto::_SyncActionValue_LabelEditAction_default_instance_);
}
inline const ::proto::SyncActionValue_LabelEditAction& SyncActionValue::labeleditaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelEditAction)
  return _internal_labeleditaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_labeleditaction(
    ::proto::SyncActionValue_LabelEditAction* labeleditaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labeleditaction_);
  }
  _impl_.labeleditaction_ = labeleditaction;
  if (labeleditaction) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelEditAction)
}
inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::release_labeleditaction() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_;
  _impl_.labeleditaction_ = 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 ::proto::SyncActionValue_LabelEditAction* SyncActionValue::unsafe_arena_release_labeleditaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelEditAction)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::SyncActionValue_LabelEditAction* temp = _impl_.labeleditaction_;
  _impl_.labeleditaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::_internal_mutable_labeleditaction() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.labeleditaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelEditAction>(GetArenaForAllocation());
    _impl_.labeleditaction_ = p;
  }
  return _impl_.labeleditaction_;
}
inline ::proto::SyncActionValue_LabelEditAction* SyncActionValue::mutable_labeleditaction() {
  ::proto::SyncActionValue_LabelEditAction* _msg = _internal_mutable_labeleditaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelEditAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_labeleditaction(::proto::SyncActionValue_LabelEditAction* labeleditaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.labeleditaction_;
  }
  if (labeleditaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labeleditaction);
    if (message_arena != submessage_arena) {
      labeleditaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, labeleditaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.labeleditaction_ = labeleditaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelEditAction)
}

// optional .proto.SyncActionValue.LabelAssociationAction labelAssociationAction = 15;
inline bool SyncActionValue::_internal_has_labelassociationaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.labelassociationaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_labelassociationaction() const {
  return _internal_has_labelassociationaction();
}
inline void SyncActionValue::clear_labelassociationaction() {
  if (_impl_.labelassociationaction_ != nullptr) _impl_.labelassociationaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::_internal_labelassociationaction() const {
  const ::proto::SyncActionValue_LabelAssociationAction* p = _impl_.labelassociationaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LabelAssociationAction&>(
      ::proto::_SyncActionValue_LabelAssociationAction_default_instance_);
}
inline const ::proto::SyncActionValue_LabelAssociationAction& SyncActionValue::labelassociationaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.labelAssociationAction)
  return _internal_labelassociationaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_labelassociationaction(
    ::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.labelassociationaction_);
  }
  _impl_.labelassociationaction_ = labelassociationaction;
  if (labelassociationaction) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.labelAssociationAction)
}
inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::release_labelassociationaction() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_;
  _impl_.labelassociationaction_ = 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 ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::unsafe_arena_release_labelassociationaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.labelAssociationAction)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::SyncActionValue_LabelAssociationAction* temp = _impl_.labelassociationaction_;
  _impl_.labelassociationaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::_internal_mutable_labelassociationaction() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.labelassociationaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LabelAssociationAction>(GetArenaForAllocation());
    _impl_.labelassociationaction_ = p;
  }
  return _impl_.labelassociationaction_;
}
inline ::proto::SyncActionValue_LabelAssociationAction* SyncActionValue::mutable_labelassociationaction() {
  ::proto::SyncActionValue_LabelAssociationAction* _msg = _internal_mutable_labelassociationaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.labelAssociationAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_labelassociationaction(::proto::SyncActionValue_LabelAssociationAction* labelassociationaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.labelassociationaction_;
  }
  if (labelassociationaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(labelassociationaction);
    if (message_arena != submessage_arena) {
      labelassociationaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, labelassociationaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.labelassociationaction_ = labelassociationaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.labelAssociationAction)
}

// optional .proto.SyncActionValue.LocaleSetting localeSetting = 16;
inline bool SyncActionValue::_internal_has_localesetting() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.localesetting_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_localesetting() const {
  return _internal_has_localesetting();
}
inline void SyncActionValue::clear_localesetting() {
  if (_impl_.localesetting_ != nullptr) _impl_.localesetting_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::_internal_localesetting() const {
  const ::proto::SyncActionValue_LocaleSetting* p = _impl_.localesetting_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_LocaleSetting&>(
      ::proto::_SyncActionValue_LocaleSetting_default_instance_);
}
inline const ::proto::SyncActionValue_LocaleSetting& SyncActionValue::localesetting() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.localeSetting)
  return _internal_localesetting();
}
inline void SyncActionValue::unsafe_arena_set_allocated_localesetting(
    ::proto::SyncActionValue_LocaleSetting* localesetting) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.localesetting_);
  }
  _impl_.localesetting_ = localesetting;
  if (localesetting) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.localeSetting)
}
inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::release_localesetting() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_;
  _impl_.localesetting_ = 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 ::proto::SyncActionValue_LocaleSetting* SyncActionValue::unsafe_arena_release_localesetting() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.localeSetting)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::SyncActionValue_LocaleSetting* temp = _impl_.localesetting_;
  _impl_.localesetting_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::_internal_mutable_localesetting() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.localesetting_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_LocaleSetting>(GetArenaForAllocation());
    _impl_.localesetting_ = p;
  }
  return _impl_.localesetting_;
}
inline ::proto::SyncActionValue_LocaleSetting* SyncActionValue::mutable_localesetting() {
  ::proto::SyncActionValue_LocaleSetting* _msg = _internal_mutable_localesetting();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.localeSetting)
  return _msg;
}
inline void SyncActionValue::set_allocated_localesetting(::proto::SyncActionValue_LocaleSetting* localesetting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.localesetting_;
  }
  if (localesetting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(localesetting);
    if (message_arena != submessage_arena) {
      localesetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, localesetting, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.localesetting_ = localesetting;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.localeSetting)
}

// optional .proto.SyncActionValue.ArchiveChatAction archiveChatAction = 17;
inline bool SyncActionValue::_internal_has_archivechataction() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.archivechataction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_archivechataction() const {
  return _internal_has_archivechataction();
}
inline void SyncActionValue::clear_archivechataction() {
  if (_impl_.archivechataction_ != nullptr) _impl_.archivechataction_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::_internal_archivechataction() const {
  const ::proto::SyncActionValue_ArchiveChatAction* p = _impl_.archivechataction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ArchiveChatAction&>(
      ::proto::_SyncActionValue_ArchiveChatAction_default_instance_);
}
inline const ::proto::SyncActionValue_ArchiveChatAction& SyncActionValue::archivechataction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.archiveChatAction)
  return _internal_archivechataction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_archivechataction(
    ::proto::SyncActionValue_ArchiveChatAction* archivechataction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.archivechataction_);
  }
  _impl_.archivechataction_ = archivechataction;
  if (archivechataction) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.archiveChatAction)
}
inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::release_archivechataction() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_;
  _impl_.archivechataction_ = 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 ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::unsafe_arena_release_archivechataction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.archiveChatAction)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::SyncActionValue_ArchiveChatAction* temp = _impl_.archivechataction_;
  _impl_.archivechataction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::_internal_mutable_archivechataction() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.archivechataction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ArchiveChatAction>(GetArenaForAllocation());
    _impl_.archivechataction_ = p;
  }
  return _impl_.archivechataction_;
}
inline ::proto::SyncActionValue_ArchiveChatAction* SyncActionValue::mutable_archivechataction() {
  ::proto::SyncActionValue_ArchiveChatAction* _msg = _internal_mutable_archivechataction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.archiveChatAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_archivechataction(::proto::SyncActionValue_ArchiveChatAction* archivechataction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.archivechataction_;
  }
  if (archivechataction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(archivechataction);
    if (message_arena != submessage_arena) {
      archivechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, archivechataction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.archivechataction_ = archivechataction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.archiveChatAction)
}

// optional .proto.SyncActionValue.DeleteMessageForMeAction deleteMessageForMeAction = 18;
inline bool SyncActionValue::_internal_has_deletemessageformeaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.deletemessageformeaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_deletemessageformeaction() const {
  return _internal_has_deletemessageformeaction();
}
inline void SyncActionValue::clear_deletemessageformeaction() {
  if (_impl_.deletemessageformeaction_ != nullptr) _impl_.deletemessageformeaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::_internal_deletemessageformeaction() const {
  const ::proto::SyncActionValue_DeleteMessageForMeAction* p = _impl_.deletemessageformeaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_DeleteMessageForMeAction&>(
      ::proto::_SyncActionValue_DeleteMessageForMeAction_default_instance_);
}
inline const ::proto::SyncActionValue_DeleteMessageForMeAction& SyncActionValue::deletemessageformeaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteMessageForMeAction)
  return _internal_deletemessageformeaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_deletemessageformeaction(
    ::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletemessageformeaction_);
  }
  _impl_.deletemessageformeaction_ = deletemessageformeaction;
  if (deletemessageformeaction) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteMessageForMeAction)
}
inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::release_deletemessageformeaction() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_;
  _impl_.deletemessageformeaction_ = 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 ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::unsafe_arena_release_deletemessageformeaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteMessageForMeAction)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::SyncActionValue_DeleteMessageForMeAction* temp = _impl_.deletemessageformeaction_;
  _impl_.deletemessageformeaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::_internal_mutable_deletemessageformeaction() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.deletemessageformeaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteMessageForMeAction>(GetArenaForAllocation());
    _impl_.deletemessageformeaction_ = p;
  }
  return _impl_.deletemessageformeaction_;
}
inline ::proto::SyncActionValue_DeleteMessageForMeAction* SyncActionValue::mutable_deletemessageformeaction() {
  ::proto::SyncActionValue_DeleteMessageForMeAction* _msg = _internal_mutable_deletemessageformeaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteMessageForMeAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_deletemessageformeaction(::proto::SyncActionValue_DeleteMessageForMeAction* deletemessageformeaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.deletemessageformeaction_;
  }
  if (deletemessageformeaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletemessageformeaction);
    if (message_arena != submessage_arena) {
      deletemessageformeaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deletemessageformeaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.deletemessageformeaction_ = deletemessageformeaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteMessageForMeAction)
}

// optional .proto.SyncActionValue.KeyExpiration keyExpiration = 19;
inline bool SyncActionValue::_internal_has_keyexpiration() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keyexpiration_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_keyexpiration() const {
  return _internal_has_keyexpiration();
}
inline void SyncActionValue::clear_keyexpiration() {
  if (_impl_.keyexpiration_ != nullptr) _impl_.keyexpiration_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::_internal_keyexpiration() const {
  const ::proto::SyncActionValue_KeyExpiration* p = _impl_.keyexpiration_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_KeyExpiration&>(
      ::proto::_SyncActionValue_KeyExpiration_default_instance_);
}
inline const ::proto::SyncActionValue_KeyExpiration& SyncActionValue::keyexpiration() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.keyExpiration)
  return _internal_keyexpiration();
}
inline void SyncActionValue::unsafe_arena_set_allocated_keyexpiration(
    ::proto::SyncActionValue_KeyExpiration* keyexpiration) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyexpiration_);
  }
  _impl_.keyexpiration_ = keyexpiration;
  if (keyexpiration) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.keyExpiration)
}
inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::release_keyexpiration() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_;
  _impl_.keyexpiration_ = 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 ::proto::SyncActionValue_KeyExpiration* SyncActionValue::unsafe_arena_release_keyexpiration() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.keyExpiration)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::SyncActionValue_KeyExpiration* temp = _impl_.keyexpiration_;
  _impl_.keyexpiration_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::_internal_mutable_keyexpiration() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.keyexpiration_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_KeyExpiration>(GetArenaForAllocation());
    _impl_.keyexpiration_ = p;
  }
  return _impl_.keyexpiration_;
}
inline ::proto::SyncActionValue_KeyExpiration* SyncActionValue::mutable_keyexpiration() {
  ::proto::SyncActionValue_KeyExpiration* _msg = _internal_mutable_keyexpiration();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.keyExpiration)
  return _msg;
}
inline void SyncActionValue::set_allocated_keyexpiration(::proto::SyncActionValue_KeyExpiration* keyexpiration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keyexpiration_;
  }
  if (keyexpiration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyexpiration);
    if (message_arena != submessage_arena) {
      keyexpiration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keyexpiration, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.keyexpiration_ = keyexpiration;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.keyExpiration)
}

// optional .proto.SyncActionValue.MarkChatAsReadAction markChatAsReadAction = 20;
inline bool SyncActionValue::_internal_has_markchatasreadaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.markchatasreadaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_markchatasreadaction() const {
  return _internal_has_markchatasreadaction();
}
inline void SyncActionValue::clear_markchatasreadaction() {
  if (_impl_.markchatasreadaction_ != nullptr) _impl_.markchatasreadaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::_internal_markchatasreadaction() const {
  const ::proto::SyncActionValue_MarkChatAsReadAction* p = _impl_.markchatasreadaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_MarkChatAsReadAction&>(
      ::proto::_SyncActionValue_MarkChatAsReadAction_default_instance_);
}
inline const ::proto::SyncActionValue_MarkChatAsReadAction& SyncActionValue::markchatasreadaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.markChatAsReadAction)
  return _internal_markchatasreadaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_markchatasreadaction(
    ::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.markchatasreadaction_);
  }
  _impl_.markchatasreadaction_ = markchatasreadaction;
  if (markchatasreadaction) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.markChatAsReadAction)
}
inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::release_markchatasreadaction() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_;
  _impl_.markchatasreadaction_ = 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 ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::unsafe_arena_release_markchatasreadaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.markChatAsReadAction)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::SyncActionValue_MarkChatAsReadAction* temp = _impl_.markchatasreadaction_;
  _impl_.markchatasreadaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::_internal_mutable_markchatasreadaction() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.markchatasreadaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_MarkChatAsReadAction>(GetArenaForAllocation());
    _impl_.markchatasreadaction_ = p;
  }
  return _impl_.markchatasreadaction_;
}
inline ::proto::SyncActionValue_MarkChatAsReadAction* SyncActionValue::mutable_markchatasreadaction() {
  ::proto::SyncActionValue_MarkChatAsReadAction* _msg = _internal_mutable_markchatasreadaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.markChatAsReadAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_markchatasreadaction(::proto::SyncActionValue_MarkChatAsReadAction* markchatasreadaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.markchatasreadaction_;
  }
  if (markchatasreadaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(markchatasreadaction);
    if (message_arena != submessage_arena) {
      markchatasreadaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, markchatasreadaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.markchatasreadaction_ = markchatasreadaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.markChatAsReadAction)
}

// optional .proto.SyncActionValue.ClearChatAction clearChatAction = 21;
inline bool SyncActionValue::_internal_has_clearchataction() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.clearchataction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_clearchataction() const {
  return _internal_has_clearchataction();
}
inline void SyncActionValue::clear_clearchataction() {
  if (_impl_.clearchataction_ != nullptr) _impl_.clearchataction_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::_internal_clearchataction() const {
  const ::proto::SyncActionValue_ClearChatAction* p = _impl_.clearchataction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_ClearChatAction&>(
      ::proto::_SyncActionValue_ClearChatAction_default_instance_);
}
inline const ::proto::SyncActionValue_ClearChatAction& SyncActionValue::clearchataction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.clearChatAction)
  return _internal_clearchataction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_clearchataction(
    ::proto::SyncActionValue_ClearChatAction* clearchataction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.clearchataction_);
  }
  _impl_.clearchataction_ = clearchataction;
  if (clearchataction) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.clearChatAction)
}
inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::release_clearchataction() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_;
  _impl_.clearchataction_ = 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 ::proto::SyncActionValue_ClearChatAction* SyncActionValue::unsafe_arena_release_clearchataction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.clearChatAction)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::SyncActionValue_ClearChatAction* temp = _impl_.clearchataction_;
  _impl_.clearchataction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::_internal_mutable_clearchataction() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.clearchataction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_ClearChatAction>(GetArenaForAllocation());
    _impl_.clearchataction_ = p;
  }
  return _impl_.clearchataction_;
}
inline ::proto::SyncActionValue_ClearChatAction* SyncActionValue::mutable_clearchataction() {
  ::proto::SyncActionValue_ClearChatAction* _msg = _internal_mutable_clearchataction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.clearChatAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_clearchataction(::proto::SyncActionValue_ClearChatAction* clearchataction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.clearchataction_;
  }
  if (clearchataction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(clearchataction);
    if (message_arena != submessage_arena) {
      clearchataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, clearchataction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.clearchataction_ = clearchataction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.clearChatAction)
}

// optional .proto.SyncActionValue.DeleteChatAction deleteChatAction = 22;
inline bool SyncActionValue::_internal_has_deletechataction() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.deletechataction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_deletechataction() const {
  return _internal_has_deletechataction();
}
inline void SyncActionValue::clear_deletechataction() {
  if (_impl_.deletechataction_ != nullptr) _impl_.deletechataction_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::_internal_deletechataction() const {
  const ::proto::SyncActionValue_DeleteChatAction* p = _impl_.deletechataction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_DeleteChatAction&>(
      ::proto::_SyncActionValue_DeleteChatAction_default_instance_);
}
inline const ::proto::SyncActionValue_DeleteChatAction& SyncActionValue::deletechataction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.deleteChatAction)
  return _internal_deletechataction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_deletechataction(
    ::proto::SyncActionValue_DeleteChatAction* deletechataction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.deletechataction_);
  }
  _impl_.deletechataction_ = deletechataction;
  if (deletechataction) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.deleteChatAction)
}
inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::release_deletechataction() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_;
  _impl_.deletechataction_ = 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 ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::unsafe_arena_release_deletechataction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.deleteChatAction)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::SyncActionValue_DeleteChatAction* temp = _impl_.deletechataction_;
  _impl_.deletechataction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::_internal_mutable_deletechataction() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.deletechataction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_DeleteChatAction>(GetArenaForAllocation());
    _impl_.deletechataction_ = p;
  }
  return _impl_.deletechataction_;
}
inline ::proto::SyncActionValue_DeleteChatAction* SyncActionValue::mutable_deletechataction() {
  ::proto::SyncActionValue_DeleteChatAction* _msg = _internal_mutable_deletechataction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.deleteChatAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_deletechataction(::proto::SyncActionValue_DeleteChatAction* deletechataction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.deletechataction_;
  }
  if (deletechataction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deletechataction);
    if (message_arena != submessage_arena) {
      deletechataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deletechataction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.deletechataction_ = deletechataction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.deleteChatAction)
}

// optional .proto.SyncActionValue.UnarchiveChatsSetting unarchiveChatsSetting = 23;
inline bool SyncActionValue::_internal_has_unarchivechatssetting() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.unarchivechatssetting_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_unarchivechatssetting() const {
  return _internal_has_unarchivechatssetting();
}
inline void SyncActionValue::clear_unarchivechatssetting() {
  if (_impl_.unarchivechatssetting_ != nullptr) _impl_.unarchivechatssetting_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::_internal_unarchivechatssetting() const {
  const ::proto::SyncActionValue_UnarchiveChatsSetting* p = _impl_.unarchivechatssetting_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_UnarchiveChatsSetting&>(
      ::proto::_SyncActionValue_UnarchiveChatsSetting_default_instance_);
}
inline const ::proto::SyncActionValue_UnarchiveChatsSetting& SyncActionValue::unarchivechatssetting() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.unarchiveChatsSetting)
  return _internal_unarchivechatssetting();
}
inline void SyncActionValue::unsafe_arena_set_allocated_unarchivechatssetting(
    ::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unarchivechatssetting_);
  }
  _impl_.unarchivechatssetting_ = unarchivechatssetting;
  if (unarchivechatssetting) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.unarchiveChatsSetting)
}
inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::release_unarchivechatssetting() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_;
  _impl_.unarchivechatssetting_ = 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 ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::unsafe_arena_release_unarchivechatssetting() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.unarchiveChatsSetting)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::SyncActionValue_UnarchiveChatsSetting* temp = _impl_.unarchivechatssetting_;
  _impl_.unarchivechatssetting_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::_internal_mutable_unarchivechatssetting() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.unarchivechatssetting_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_UnarchiveChatsSetting>(GetArenaForAllocation());
    _impl_.unarchivechatssetting_ = p;
  }
  return _impl_.unarchivechatssetting_;
}
inline ::proto::SyncActionValue_UnarchiveChatsSetting* SyncActionValue::mutable_unarchivechatssetting() {
  ::proto::SyncActionValue_UnarchiveChatsSetting* _msg = _internal_mutable_unarchivechatssetting();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.unarchiveChatsSetting)
  return _msg;
}
inline void SyncActionValue::set_allocated_unarchivechatssetting(::proto::SyncActionValue_UnarchiveChatsSetting* unarchivechatssetting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.unarchivechatssetting_;
  }
  if (unarchivechatssetting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unarchivechatssetting);
    if (message_arena != submessage_arena) {
      unarchivechatssetting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, unarchivechatssetting, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.unarchivechatssetting_ = unarchivechatssetting;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.unarchiveChatsSetting)
}

// optional .proto.SyncActionValue.PrimaryFeature primaryFeature = 24;
inline bool SyncActionValue::_internal_has_primaryfeature() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.primaryfeature_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_primaryfeature() const {
  return _internal_has_primaryfeature();
}
inline void SyncActionValue::clear_primaryfeature() {
  if (_impl_.primaryfeature_ != nullptr) _impl_.primaryfeature_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::_internal_primaryfeature() const {
  const ::proto::SyncActionValue_PrimaryFeature* p = _impl_.primaryfeature_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PrimaryFeature&>(
      ::proto::_SyncActionValue_PrimaryFeature_default_instance_);
}
inline const ::proto::SyncActionValue_PrimaryFeature& SyncActionValue::primaryfeature() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryFeature)
  return _internal_primaryfeature();
}
inline void SyncActionValue::unsafe_arena_set_allocated_primaryfeature(
    ::proto::SyncActionValue_PrimaryFeature* primaryfeature) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryfeature_);
  }
  _impl_.primaryfeature_ = primaryfeature;
  if (primaryfeature) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryFeature)
}
inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::release_primaryfeature() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_;
  _impl_.primaryfeature_ = 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 ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::unsafe_arena_release_primaryfeature() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryFeature)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::SyncActionValue_PrimaryFeature* temp = _impl_.primaryfeature_;
  _impl_.primaryfeature_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::_internal_mutable_primaryfeature() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.primaryfeature_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryFeature>(GetArenaForAllocation());
    _impl_.primaryfeature_ = p;
  }
  return _impl_.primaryfeature_;
}
inline ::proto::SyncActionValue_PrimaryFeature* SyncActionValue::mutable_primaryfeature() {
  ::proto::SyncActionValue_PrimaryFeature* _msg = _internal_mutable_primaryfeature();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryFeature)
  return _msg;
}
inline void SyncActionValue::set_allocated_primaryfeature(::proto::SyncActionValue_PrimaryFeature* primaryfeature) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.primaryfeature_;
  }
  if (primaryfeature) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryfeature);
    if (message_arena != submessage_arena) {
      primaryfeature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, primaryfeature, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.primaryfeature_ = primaryfeature;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryFeature)
}

// optional .proto.SyncActionValue.AndroidUnsupportedActions androidUnsupportedActions = 26;
inline bool SyncActionValue::_internal_has_androidunsupportedactions() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.androidunsupportedactions_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_androidunsupportedactions() const {
  return _internal_has_androidunsupportedactions();
}
inline void SyncActionValue::clear_androidunsupportedactions() {
  if (_impl_.androidunsupportedactions_ != nullptr) _impl_.androidunsupportedactions_->Clear();
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::_internal_androidunsupportedactions() const {
  const ::proto::SyncActionValue_AndroidUnsupportedActions* p = _impl_.androidunsupportedactions_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_AndroidUnsupportedActions&>(
      ::proto::_SyncActionValue_AndroidUnsupportedActions_default_instance_);
}
inline const ::proto::SyncActionValue_AndroidUnsupportedActions& SyncActionValue::androidunsupportedactions() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.androidUnsupportedActions)
  return _internal_androidunsupportedactions();
}
inline void SyncActionValue::unsafe_arena_set_allocated_androidunsupportedactions(
    ::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.androidunsupportedactions_);
  }
  _impl_.androidunsupportedactions_ = androidunsupportedactions;
  if (androidunsupportedactions) {
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.androidUnsupportedActions)
}
inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::release_androidunsupportedactions() {
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_;
  _impl_.androidunsupportedactions_ = 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 ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::unsafe_arena_release_androidunsupportedactions() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.androidUnsupportedActions)
  _impl_._has_bits_[0] &= ~0x00080000u;
  ::proto::SyncActionValue_AndroidUnsupportedActions* temp = _impl_.androidunsupportedactions_;
  _impl_.androidunsupportedactions_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::_internal_mutable_androidunsupportedactions() {
  _impl_._has_bits_[0] |= 0x00080000u;
  if (_impl_.androidunsupportedactions_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_AndroidUnsupportedActions>(GetArenaForAllocation());
    _impl_.androidunsupportedactions_ = p;
  }
  return _impl_.androidunsupportedactions_;
}
inline ::proto::SyncActionValue_AndroidUnsupportedActions* SyncActionValue::mutable_androidunsupportedactions() {
  ::proto::SyncActionValue_AndroidUnsupportedActions* _msg = _internal_mutable_androidunsupportedactions();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.androidUnsupportedActions)
  return _msg;
}
inline void SyncActionValue::set_allocated_androidunsupportedactions(::proto::SyncActionValue_AndroidUnsupportedActions* androidunsupportedactions) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.androidunsupportedactions_;
  }
  if (androidunsupportedactions) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(androidunsupportedactions);
    if (message_arena != submessage_arena) {
      androidunsupportedactions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, androidunsupportedactions, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00080000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00080000u;
  }
  _impl_.androidunsupportedactions_ = androidunsupportedactions;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.androidUnsupportedActions)
}

// optional .proto.SyncActionValue.AgentAction agentAction = 27;
inline bool SyncActionValue::_internal_has_agentaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.agentaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_agentaction() const {
  return _internal_has_agentaction();
}
inline void SyncActionValue::clear_agentaction() {
  if (_impl_.agentaction_ != nullptr) _impl_.agentaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::_internal_agentaction() const {
  const ::proto::SyncActionValue_AgentAction* p = _impl_.agentaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_AgentAction&>(
      ::proto::_SyncActionValue_AgentAction_default_instance_);
}
inline const ::proto::SyncActionValue_AgentAction& SyncActionValue::agentaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.agentAction)
  return _internal_agentaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_agentaction(
    ::proto::SyncActionValue_AgentAction* agentaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.agentaction_);
  }
  _impl_.agentaction_ = agentaction;
  if (agentaction) {
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.agentAction)
}
inline ::proto::SyncActionValue_AgentAction* SyncActionValue::release_agentaction() {
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_;
  _impl_.agentaction_ = 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 ::proto::SyncActionValue_AgentAction* SyncActionValue::unsafe_arena_release_agentaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.agentAction)
  _impl_._has_bits_[0] &= ~0x00100000u;
  ::proto::SyncActionValue_AgentAction* temp = _impl_.agentaction_;
  _impl_.agentaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_AgentAction* SyncActionValue::_internal_mutable_agentaction() {
  _impl_._has_bits_[0] |= 0x00100000u;
  if (_impl_.agentaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_AgentAction>(GetArenaForAllocation());
    _impl_.agentaction_ = p;
  }
  return _impl_.agentaction_;
}
inline ::proto::SyncActionValue_AgentAction* SyncActionValue::mutable_agentaction() {
  ::proto::SyncActionValue_AgentAction* _msg = _internal_mutable_agentaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.agentAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_agentaction(::proto::SyncActionValue_AgentAction* agentaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.agentaction_;
  }
  if (agentaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(agentaction);
    if (message_arena != submessage_arena) {
      agentaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, agentaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00100000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00100000u;
  }
  _impl_.agentaction_ = agentaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.agentAction)
}

// optional .proto.SyncActionValue.SubscriptionAction subscriptionAction = 28;
inline bool SyncActionValue::_internal_has_subscriptionaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.subscriptionaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_subscriptionaction() const {
  return _internal_has_subscriptionaction();
}
inline void SyncActionValue::clear_subscriptionaction() {
  if (_impl_.subscriptionaction_ != nullptr) _impl_.subscriptionaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::_internal_subscriptionaction() const {
  const ::proto::SyncActionValue_SubscriptionAction* p = _impl_.subscriptionaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_SubscriptionAction&>(
      ::proto::_SyncActionValue_SubscriptionAction_default_instance_);
}
inline const ::proto::SyncActionValue_SubscriptionAction& SyncActionValue::subscriptionaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.subscriptionAction)
  return _internal_subscriptionaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_subscriptionaction(
    ::proto::SyncActionValue_SubscriptionAction* subscriptionaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.subscriptionaction_);
  }
  _impl_.subscriptionaction_ = subscriptionaction;
  if (subscriptionaction) {
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.subscriptionAction)
}
inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::release_subscriptionaction() {
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_;
  _impl_.subscriptionaction_ = 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 ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::unsafe_arena_release_subscriptionaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.subscriptionAction)
  _impl_._has_bits_[0] &= ~0x00200000u;
  ::proto::SyncActionValue_SubscriptionAction* temp = _impl_.subscriptionaction_;
  _impl_.subscriptionaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::_internal_mutable_subscriptionaction() {
  _impl_._has_bits_[0] |= 0x00200000u;
  if (_impl_.subscriptionaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_SubscriptionAction>(GetArenaForAllocation());
    _impl_.subscriptionaction_ = p;
  }
  return _impl_.subscriptionaction_;
}
inline ::proto::SyncActionValue_SubscriptionAction* SyncActionValue::mutable_subscriptionaction() {
  ::proto::SyncActionValue_SubscriptionAction* _msg = _internal_mutable_subscriptionaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.subscriptionAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_subscriptionaction(::proto::SyncActionValue_SubscriptionAction* subscriptionaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.subscriptionaction_;
  }
  if (subscriptionaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(subscriptionaction);
    if (message_arena != submessage_arena) {
      subscriptionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, subscriptionaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00200000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00200000u;
  }
  _impl_.subscriptionaction_ = subscriptionaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.subscriptionAction)
}

// optional .proto.SyncActionValue.UserStatusMuteAction userStatusMuteAction = 29;
inline bool SyncActionValue::_internal_has_userstatusmuteaction() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.userstatusmuteaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_userstatusmuteaction() const {
  return _internal_has_userstatusmuteaction();
}
inline void SyncActionValue::clear_userstatusmuteaction() {
  if (_impl_.userstatusmuteaction_ != nullptr) _impl_.userstatusmuteaction_->Clear();
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::_internal_userstatusmuteaction() const {
  const ::proto::SyncActionValue_UserStatusMuteAction* p = _impl_.userstatusmuteaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_UserStatusMuteAction&>(
      ::proto::_SyncActionValue_UserStatusMuteAction_default_instance_);
}
inline const ::proto::SyncActionValue_UserStatusMuteAction& SyncActionValue::userstatusmuteaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.userStatusMuteAction)
  return _internal_userstatusmuteaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_userstatusmuteaction(
    ::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.userstatusmuteaction_);
  }
  _impl_.userstatusmuteaction_ = userstatusmuteaction;
  if (userstatusmuteaction) {
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.userStatusMuteAction)
}
inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::release_userstatusmuteaction() {
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_;
  _impl_.userstatusmuteaction_ = 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 ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::unsafe_arena_release_userstatusmuteaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.userStatusMuteAction)
  _impl_._has_bits_[0] &= ~0x00400000u;
  ::proto::SyncActionValue_UserStatusMuteAction* temp = _impl_.userstatusmuteaction_;
  _impl_.userstatusmuteaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::_internal_mutable_userstatusmuteaction() {
  _impl_._has_bits_[0] |= 0x00400000u;
  if (_impl_.userstatusmuteaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_UserStatusMuteAction>(GetArenaForAllocation());
    _impl_.userstatusmuteaction_ = p;
  }
  return _impl_.userstatusmuteaction_;
}
inline ::proto::SyncActionValue_UserStatusMuteAction* SyncActionValue::mutable_userstatusmuteaction() {
  ::proto::SyncActionValue_UserStatusMuteAction* _msg = _internal_mutable_userstatusmuteaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.userStatusMuteAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_userstatusmuteaction(::proto::SyncActionValue_UserStatusMuteAction* userstatusmuteaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.userstatusmuteaction_;
  }
  if (userstatusmuteaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(userstatusmuteaction);
    if (message_arena != submessage_arena) {
      userstatusmuteaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, userstatusmuteaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00400000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00400000u;
  }
  _impl_.userstatusmuteaction_ = userstatusmuteaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.userStatusMuteAction)
}

// optional .proto.SyncActionValue.TimeFormatAction timeFormatAction = 30;
inline bool SyncActionValue::_internal_has_timeformataction() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.timeformataction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_timeformataction() const {
  return _internal_has_timeformataction();
}
inline void SyncActionValue::clear_timeformataction() {
  if (_impl_.timeformataction_ != nullptr) _impl_.timeformataction_->Clear();
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::_internal_timeformataction() const {
  const ::proto::SyncActionValue_TimeFormatAction* p = _impl_.timeformataction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_TimeFormatAction&>(
      ::proto::_SyncActionValue_TimeFormatAction_default_instance_);
}
inline const ::proto::SyncActionValue_TimeFormatAction& SyncActionValue::timeformataction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.timeFormatAction)
  return _internal_timeformataction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_timeformataction(
    ::proto::SyncActionValue_TimeFormatAction* timeformataction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.timeformataction_);
  }
  _impl_.timeformataction_ = timeformataction;
  if (timeformataction) {
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.timeFormatAction)
}
inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::release_timeformataction() {
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_;
  _impl_.timeformataction_ = 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 ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::unsafe_arena_release_timeformataction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.timeFormatAction)
  _impl_._has_bits_[0] &= ~0x00800000u;
  ::proto::SyncActionValue_TimeFormatAction* temp = _impl_.timeformataction_;
  _impl_.timeformataction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::_internal_mutable_timeformataction() {
  _impl_._has_bits_[0] |= 0x00800000u;
  if (_impl_.timeformataction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_TimeFormatAction>(GetArenaForAllocation());
    _impl_.timeformataction_ = p;
  }
  return _impl_.timeformataction_;
}
inline ::proto::SyncActionValue_TimeFormatAction* SyncActionValue::mutable_timeformataction() {
  ::proto::SyncActionValue_TimeFormatAction* _msg = _internal_mutable_timeformataction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.timeFormatAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_timeformataction(::proto::SyncActionValue_TimeFormatAction* timeformataction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.timeformataction_;
  }
  if (timeformataction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(timeformataction);
    if (message_arena != submessage_arena) {
      timeformataction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timeformataction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00800000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00800000u;
  }
  _impl_.timeformataction_ = timeformataction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.timeFormatAction)
}

// optional .proto.SyncActionValue.NuxAction nuxAction = 31;
inline bool SyncActionValue::_internal_has_nuxaction() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.nuxaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_nuxaction() const {
  return _internal_has_nuxaction();
}
inline void SyncActionValue::clear_nuxaction() {
  if (_impl_.nuxaction_ != nullptr) _impl_.nuxaction_->Clear();
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::_internal_nuxaction() const {
  const ::proto::SyncActionValue_NuxAction* p = _impl_.nuxaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_NuxAction&>(
      ::proto::_SyncActionValue_NuxAction_default_instance_);
}
inline const ::proto::SyncActionValue_NuxAction& SyncActionValue::nuxaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.nuxAction)
  return _internal_nuxaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_nuxaction(
    ::proto::SyncActionValue_NuxAction* nuxaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.nuxaction_);
  }
  _impl_.nuxaction_ = nuxaction;
  if (nuxaction) {
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.nuxAction)
}
inline ::proto::SyncActionValue_NuxAction* SyncActionValue::release_nuxaction() {
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_;
  _impl_.nuxaction_ = 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 ::proto::SyncActionValue_NuxAction* SyncActionValue::unsafe_arena_release_nuxaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.nuxAction)
  _impl_._has_bits_[0] &= ~0x01000000u;
  ::proto::SyncActionValue_NuxAction* temp = _impl_.nuxaction_;
  _impl_.nuxaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_NuxAction* SyncActionValue::_internal_mutable_nuxaction() {
  _impl_._has_bits_[0] |= 0x01000000u;
  if (_impl_.nuxaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_NuxAction>(GetArenaForAllocation());
    _impl_.nuxaction_ = p;
  }
  return _impl_.nuxaction_;
}
inline ::proto::SyncActionValue_NuxAction* SyncActionValue::mutable_nuxaction() {
  ::proto::SyncActionValue_NuxAction* _msg = _internal_mutable_nuxaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.nuxAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_nuxaction(::proto::SyncActionValue_NuxAction* nuxaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.nuxaction_;
  }
  if (nuxaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(nuxaction);
    if (message_arena != submessage_arena) {
      nuxaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, nuxaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x01000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x01000000u;
  }
  _impl_.nuxaction_ = nuxaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.nuxAction)
}

// optional .proto.SyncActionValue.PrimaryVersionAction primaryVersionAction = 32;
inline bool SyncActionValue::_internal_has_primaryversionaction() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.primaryversionaction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_primaryversionaction() const {
  return _internal_has_primaryversionaction();
}
inline void SyncActionValue::clear_primaryversionaction() {
  if (_impl_.primaryversionaction_ != nullptr) _impl_.primaryversionaction_->Clear();
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::_internal_primaryversionaction() const {
  const ::proto::SyncActionValue_PrimaryVersionAction* p = _impl_.primaryversionaction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_PrimaryVersionAction&>(
      ::proto::_SyncActionValue_PrimaryVersionAction_default_instance_);
}
inline const ::proto::SyncActionValue_PrimaryVersionAction& SyncActionValue::primaryversionaction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.primaryVersionAction)
  return _internal_primaryversionaction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_primaryversionaction(
    ::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.primaryversionaction_);
  }
  _impl_.primaryversionaction_ = primaryversionaction;
  if (primaryversionaction) {
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.primaryVersionAction)
}
inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::release_primaryversionaction() {
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_;
  _impl_.primaryversionaction_ = 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 ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::unsafe_arena_release_primaryversionaction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.primaryVersionAction)
  _impl_._has_bits_[0] &= ~0x02000000u;
  ::proto::SyncActionValue_PrimaryVersionAction* temp = _impl_.primaryversionaction_;
  _impl_.primaryversionaction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::_internal_mutable_primaryversionaction() {
  _impl_._has_bits_[0] |= 0x02000000u;
  if (_impl_.primaryversionaction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_PrimaryVersionAction>(GetArenaForAllocation());
    _impl_.primaryversionaction_ = p;
  }
  return _impl_.primaryversionaction_;
}
inline ::proto::SyncActionValue_PrimaryVersionAction* SyncActionValue::mutable_primaryversionaction() {
  ::proto::SyncActionValue_PrimaryVersionAction* _msg = _internal_mutable_primaryversionaction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.primaryVersionAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_primaryversionaction(::proto::SyncActionValue_PrimaryVersionAction* primaryversionaction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.primaryversionaction_;
  }
  if (primaryversionaction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(primaryversionaction);
    if (message_arena != submessage_arena) {
      primaryversionaction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, primaryversionaction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x02000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x02000000u;
  }
  _impl_.primaryversionaction_ = primaryversionaction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.primaryVersionAction)
}

// optional .proto.SyncActionValue.StickerAction stickerAction = 33;
inline bool SyncActionValue::_internal_has_stickeraction() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.stickeraction_ != nullptr);
  return value;
}
inline bool SyncActionValue::has_stickeraction() const {
  return _internal_has_stickeraction();
}
inline void SyncActionValue::clear_stickeraction() {
  if (_impl_.stickeraction_ != nullptr) _impl_.stickeraction_->Clear();
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::_internal_stickeraction() const {
  const ::proto::SyncActionValue_StickerAction* p = _impl_.stickeraction_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncActionValue_StickerAction&>(
      ::proto::_SyncActionValue_StickerAction_default_instance_);
}
inline const ::proto::SyncActionValue_StickerAction& SyncActionValue::stickeraction() const {
  // @@protoc_insertion_point(field_get:proto.SyncActionValue.stickerAction)
  return _internal_stickeraction();
}
inline void SyncActionValue::unsafe_arena_set_allocated_stickeraction(
    ::proto::SyncActionValue_StickerAction* stickeraction) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.stickeraction_);
  }
  _impl_.stickeraction_ = stickeraction;
  if (stickeraction) {
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncActionValue.stickerAction)
}
inline ::proto::SyncActionValue_StickerAction* SyncActionValue::release_stickeraction() {
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_;
  _impl_.stickeraction_ = 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 ::proto::SyncActionValue_StickerAction* SyncActionValue::unsafe_arena_release_stickeraction() {
  // @@protoc_insertion_point(field_release:proto.SyncActionValue.stickerAction)
  _impl_._has_bits_[0] &= ~0x04000000u;
  ::proto::SyncActionValue_StickerAction* temp = _impl_.stickeraction_;
  _impl_.stickeraction_ = nullptr;
  return temp;
}
inline ::proto::SyncActionValue_StickerAction* SyncActionValue::_internal_mutable_stickeraction() {
  _impl_._has_bits_[0] |= 0x04000000u;
  if (_impl_.stickeraction_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncActionValue_StickerAction>(GetArenaForAllocation());
    _impl_.stickeraction_ = p;
  }
  return _impl_.stickeraction_;
}
inline ::proto::SyncActionValue_StickerAction* SyncActionValue::mutable_stickeraction() {
  ::proto::SyncActionValue_StickerAction* _msg = _internal_mutable_stickeraction();
  // @@protoc_insertion_point(field_mutable:proto.SyncActionValue.stickerAction)
  return _msg;
}
inline void SyncActionValue::set_allocated_stickeraction(::proto::SyncActionValue_StickerAction* stickeraction) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.stickeraction_;
  }
  if (stickeraction) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(stickeraction);
    if (message_arena != submessage_arena) {
      stickeraction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, stickeraction, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x04000000u;
  } else {
    _impl_._has_bits_[0] &= ~0x04000000u;
  }
  _impl_.stickeraction_ = stickeraction;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncActionValue.stickerAction)
}

// -------------------------------------------------------------------

// SyncdIndex

// optional bytes blob = 1;
inline bool SyncdIndex::_internal_has_blob() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncdIndex::has_blob() const {
  return _internal_has_blob();
}
inline void SyncdIndex::clear_blob() {
  _impl_.blob_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncdIndex::blob() const {
  // @@protoc_insertion_point(field_get:proto.SyncdIndex.blob)
  return _internal_blob();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncdIndex::set_blob(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.blob_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncdIndex.blob)
}
inline std::string* SyncdIndex::mutable_blob() {
  std::string* _s = _internal_mutable_blob();
  // @@protoc_insertion_point(field_mutable:proto.SyncdIndex.blob)
  return _s;
}
inline const std::string& SyncdIndex::_internal_blob() const {
  return _impl_.blob_.Get();
}
inline void SyncdIndex::_internal_set_blob(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.blob_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncdIndex::_internal_mutable_blob() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.blob_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncdIndex::release_blob() {
  // @@protoc_insertion_point(field_release:proto.SyncdIndex.blob)
  if (!_internal_has_blob()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.blob_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.blob_.IsDefault()) {
    _impl_.blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncdIndex::set_allocated_blob(std::string* blob) {
  if (blob != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.blob_.SetAllocated(blob, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.blob_.IsDefault()) {
    _impl_.blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdIndex.blob)
}

// -------------------------------------------------------------------

// SyncdMutation

// optional .proto.SyncdMutation.SyncdOperation operation = 1;
inline bool SyncdMutation::_internal_has_operation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncdMutation::has_operation() const {
  return _internal_has_operation();
}
inline void SyncdMutation::clear_operation() {
  _impl_.operation_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::_internal_operation() const {
  return static_cast< ::proto::SyncdMutation_SyncdOperation >(_impl_.operation_);
}
inline ::proto::SyncdMutation_SyncdOperation SyncdMutation::operation() const {
  // @@protoc_insertion_point(field_get:proto.SyncdMutation.operation)
  return _internal_operation();
}
inline void SyncdMutation::_internal_set_operation(::proto::SyncdMutation_SyncdOperation value) {
  assert(::proto::SyncdMutation_SyncdOperation_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.operation_ = value;
}
inline void SyncdMutation::set_operation(::proto::SyncdMutation_SyncdOperation value) {
  _internal_set_operation(value);
  // @@protoc_insertion_point(field_set:proto.SyncdMutation.operation)
}

// optional .proto.SyncdRecord record = 2;
inline bool SyncdMutation::_internal_has_record() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.record_ != nullptr);
  return value;
}
inline bool SyncdMutation::has_record() const {
  return _internal_has_record();
}
inline void SyncdMutation::clear_record() {
  if (_impl_.record_ != nullptr) _impl_.record_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncdRecord& SyncdMutation::_internal_record() const {
  const ::proto::SyncdRecord* p = _impl_.record_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdRecord&>(
      ::proto::_SyncdRecord_default_instance_);
}
inline const ::proto::SyncdRecord& SyncdMutation::record() const {
  // @@protoc_insertion_point(field_get:proto.SyncdMutation.record)
  return _internal_record();
}
inline void SyncdMutation::unsafe_arena_set_allocated_record(
    ::proto::SyncdRecord* record) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.record_);
  }
  _impl_.record_ = record;
  if (record) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdMutation.record)
}
inline ::proto::SyncdRecord* SyncdMutation::release_record() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncdRecord* temp = _impl_.record_;
  _impl_.record_ = 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 ::proto::SyncdRecord* SyncdMutation::unsafe_arena_release_record() {
  // @@protoc_insertion_point(field_release:proto.SyncdMutation.record)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncdRecord* temp = _impl_.record_;
  _impl_.record_ = nullptr;
  return temp;
}
inline ::proto::SyncdRecord* SyncdMutation::_internal_mutable_record() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.record_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncdRecord>(GetArenaForAllocation());
    _impl_.record_ = p;
  }
  return _impl_.record_;
}
inline ::proto::SyncdRecord* SyncdMutation::mutable_record() {
  ::proto::SyncdRecord* _msg = _internal_mutable_record();
  // @@protoc_insertion_point(field_mutable:proto.SyncdMutation.record)
  return _msg;
}
inline void SyncdMutation::set_allocated_record(::proto::SyncdRecord* record) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.record_;
  }
  if (record) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(record);
    if (message_arena != submessage_arena) {
      record = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, record, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.record_ = record;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdMutation.record)
}

// -------------------------------------------------------------------

// SyncdMutations

// repeated .proto.SyncdMutation mutations = 1;
inline int SyncdMutations::_internal_mutations_size() const {
  return _impl_.mutations_.size();
}
inline int SyncdMutations::mutations_size() const {
  return _internal_mutations_size();
}
inline void SyncdMutations::clear_mutations() {
  _impl_.mutations_.Clear();
}
inline ::proto::SyncdMutation* SyncdMutations::mutable_mutations(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncdMutations.mutations)
  return _impl_.mutations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
SyncdMutations::mutable_mutations() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncdMutations.mutations)
  return &_impl_.mutations_;
}
inline const ::proto::SyncdMutation& SyncdMutations::_internal_mutations(int index) const {
  return _impl_.mutations_.Get(index);
}
inline const ::proto::SyncdMutation& SyncdMutations::mutations(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncdMutations.mutations)
  return _internal_mutations(index);
}
inline ::proto::SyncdMutation* SyncdMutations::_internal_add_mutations() {
  return _impl_.mutations_.Add();
}
inline ::proto::SyncdMutation* SyncdMutations::add_mutations() {
  ::proto::SyncdMutation* _add = _internal_add_mutations();
  // @@protoc_insertion_point(field_add:proto.SyncdMutations.mutations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
SyncdMutations::mutations() const {
  // @@protoc_insertion_point(field_list:proto.SyncdMutations.mutations)
  return _impl_.mutations_;
}

// -------------------------------------------------------------------

// SyncdPatch

// optional .proto.SyncdVersion version = 1;
inline bool SyncdPatch::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
  return value;
}
inline bool SyncdPatch::has_version() const {
  return _internal_has_version();
}
inline void SyncdPatch::clear_version() {
  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::SyncdVersion& SyncdPatch::_internal_version() const {
  const ::proto::SyncdVersion* p = _impl_.version_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdVersion&>(
      ::proto::_SyncdVersion_default_instance_);
}
inline const ::proto::SyncdVersion& SyncdPatch::version() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.version)
  return _internal_version();
}
inline void SyncdPatch::unsafe_arena_set_allocated_version(
    ::proto::SyncdVersion* version) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
  }
  _impl_.version_ = version;
  if (version) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.version)
}
inline ::proto::SyncdVersion* SyncdPatch::release_version() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncdVersion* temp = _impl_.version_;
  _impl_.version_ = 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 ::proto::SyncdVersion* SyncdPatch::unsafe_arena_release_version() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.version)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::SyncdVersion* temp = _impl_.version_;
  _impl_.version_ = nullptr;
  return temp;
}
inline ::proto::SyncdVersion* SyncdPatch::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.version_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation());
    _impl_.version_ = p;
  }
  return _impl_.version_;
}
inline ::proto::SyncdVersion* SyncdPatch::mutable_version() {
  ::proto::SyncdVersion* _msg = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.version)
  return _msg;
}
inline void SyncdPatch::set_allocated_version(::proto::SyncdVersion* version) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.version_;
  }
  if (version) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
    if (message_arena != submessage_arena) {
      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, version, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.version_ = version;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.version)
}

// repeated .proto.SyncdMutation mutations = 2;
inline int SyncdPatch::_internal_mutations_size() const {
  return _impl_.mutations_.size();
}
inline int SyncdPatch::mutations_size() const {
  return _internal_mutations_size();
}
inline void SyncdPatch::clear_mutations() {
  _impl_.mutations_.Clear();
}
inline ::proto::SyncdMutation* SyncdPatch::mutable_mutations(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.mutations)
  return _impl_.mutations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >*
SyncdPatch::mutable_mutations() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncdPatch.mutations)
  return &_impl_.mutations_;
}
inline const ::proto::SyncdMutation& SyncdPatch::_internal_mutations(int index) const {
  return _impl_.mutations_.Get(index);
}
inline const ::proto::SyncdMutation& SyncdPatch::mutations(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.mutations)
  return _internal_mutations(index);
}
inline ::proto::SyncdMutation* SyncdPatch::_internal_add_mutations() {
  return _impl_.mutations_.Add();
}
inline ::proto::SyncdMutation* SyncdPatch::add_mutations() {
  ::proto::SyncdMutation* _add = _internal_add_mutations();
  // @@protoc_insertion_point(field_add:proto.SyncdPatch.mutations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdMutation >&
SyncdPatch::mutations() const {
  // @@protoc_insertion_point(field_list:proto.SyncdPatch.mutations)
  return _impl_.mutations_;
}

// optional .proto.ExternalBlobReference externalMutations = 3;
inline bool SyncdPatch::_internal_has_externalmutations() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.externalmutations_ != nullptr);
  return value;
}
inline bool SyncdPatch::has_externalmutations() const {
  return _internal_has_externalmutations();
}
inline void SyncdPatch::clear_externalmutations() {
  if (_impl_.externalmutations_ != nullptr) _impl_.externalmutations_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::proto::ExternalBlobReference& SyncdPatch::_internal_externalmutations() const {
  const ::proto::ExternalBlobReference* p = _impl_.externalmutations_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ExternalBlobReference&>(
      ::proto::_ExternalBlobReference_default_instance_);
}
inline const ::proto::ExternalBlobReference& SyncdPatch::externalmutations() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.externalMutations)
  return _internal_externalmutations();
}
inline void SyncdPatch::unsafe_arena_set_allocated_externalmutations(
    ::proto::ExternalBlobReference* externalmutations) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.externalmutations_);
  }
  _impl_.externalmutations_ = externalmutations;
  if (externalmutations) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.externalMutations)
}
inline ::proto::ExternalBlobReference* SyncdPatch::release_externalmutations() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ExternalBlobReference* temp = _impl_.externalmutations_;
  _impl_.externalmutations_ = 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 ::proto::ExternalBlobReference* SyncdPatch::unsafe_arena_release_externalmutations() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.externalMutations)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::proto::ExternalBlobReference* temp = _impl_.externalmutations_;
  _impl_.externalmutations_ = nullptr;
  return temp;
}
inline ::proto::ExternalBlobReference* SyncdPatch::_internal_mutable_externalmutations() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.externalmutations_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ExternalBlobReference>(GetArenaForAllocation());
    _impl_.externalmutations_ = p;
  }
  return _impl_.externalmutations_;
}
inline ::proto::ExternalBlobReference* SyncdPatch::mutable_externalmutations() {
  ::proto::ExternalBlobReference* _msg = _internal_mutable_externalmutations();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.externalMutations)
  return _msg;
}
inline void SyncdPatch::set_allocated_externalmutations(::proto::ExternalBlobReference* externalmutations) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.externalmutations_;
  }
  if (externalmutations) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(externalmutations);
    if (message_arena != submessage_arena) {
      externalmutations = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, externalmutations, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.externalmutations_ = externalmutations;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.externalMutations)
}

// optional bytes snapshotMac = 4;
inline bool SyncdPatch::_internal_has_snapshotmac() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncdPatch::has_snapshotmac() const {
  return _internal_has_snapshotmac();
}
inline void SyncdPatch::clear_snapshotmac() {
  _impl_.snapshotmac_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncdPatch::snapshotmac() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.snapshotMac)
  return _internal_snapshotmac();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncdPatch::set_snapshotmac(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.snapshotmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncdPatch.snapshotMac)
}
inline std::string* SyncdPatch::mutable_snapshotmac() {
  std::string* _s = _internal_mutable_snapshotmac();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.snapshotMac)
  return _s;
}
inline const std::string& SyncdPatch::_internal_snapshotmac() const {
  return _impl_.snapshotmac_.Get();
}
inline void SyncdPatch::_internal_set_snapshotmac(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.snapshotmac_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncdPatch::_internal_mutable_snapshotmac() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.snapshotmac_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncdPatch::release_snapshotmac() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.snapshotMac)
  if (!_internal_has_snapshotmac()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.snapshotmac_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshotmac_.IsDefault()) {
    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncdPatch::set_allocated_snapshotmac(std::string* snapshotmac) {
  if (snapshotmac != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.snapshotmac_.SetAllocated(snapshotmac, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.snapshotmac_.IsDefault()) {
    _impl_.snapshotmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.snapshotMac)
}

// optional bytes patchMac = 5;
inline bool SyncdPatch::_internal_has_patchmac() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SyncdPatch::has_patchmac() const {
  return _internal_has_patchmac();
}
inline void SyncdPatch::clear_patchmac() {
  _impl_.patchmac_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SyncdPatch::patchmac() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.patchMac)
  return _internal_patchmac();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncdPatch::set_patchmac(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.patchmac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncdPatch.patchMac)
}
inline std::string* SyncdPatch::mutable_patchmac() {
  std::string* _s = _internal_mutable_patchmac();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.patchMac)
  return _s;
}
inline const std::string& SyncdPatch::_internal_patchmac() const {
  return _impl_.patchmac_.Get();
}
inline void SyncdPatch::_internal_set_patchmac(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.patchmac_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncdPatch::_internal_mutable_patchmac() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.patchmac_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncdPatch::release_patchmac() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.patchMac)
  if (!_internal_has_patchmac()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.patchmac_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.patchmac_.IsDefault()) {
    _impl_.patchmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncdPatch::set_allocated_patchmac(std::string* patchmac) {
  if (patchmac != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.patchmac_.SetAllocated(patchmac, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.patchmac_.IsDefault()) {
    _impl_.patchmac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.patchMac)
}

// optional .proto.KeyId keyId = 6;
inline bool SyncdPatch::_internal_has_keyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
  return value;
}
inline bool SyncdPatch::has_keyid() const {
  return _internal_has_keyid();
}
inline void SyncdPatch::clear_keyid() {
  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::proto::KeyId& SyncdPatch::_internal_keyid() const {
  const ::proto::KeyId* p = _impl_.keyid_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
      ::proto::_KeyId_default_instance_);
}
inline const ::proto::KeyId& SyncdPatch::keyid() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.keyId)
  return _internal_keyid();
}
inline void SyncdPatch::unsafe_arena_set_allocated_keyid(
    ::proto::KeyId* keyid) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
  }
  _impl_.keyid_ = keyid;
  if (keyid) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.keyId)
}
inline ::proto::KeyId* SyncdPatch::release_keyid() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = 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 ::proto::KeyId* SyncdPatch::unsafe_arena_release_keyid() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.keyId)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = nullptr;
  return temp;
}
inline ::proto::KeyId* SyncdPatch::_internal_mutable_keyid() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.keyid_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
    _impl_.keyid_ = p;
  }
  return _impl_.keyid_;
}
inline ::proto::KeyId* SyncdPatch::mutable_keyid() {
  ::proto::KeyId* _msg = _internal_mutable_keyid();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.keyId)
  return _msg;
}
inline void SyncdPatch::set_allocated_keyid(::proto::KeyId* keyid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keyid_;
  }
  if (keyid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
    if (message_arena != submessage_arena) {
      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keyid, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.keyid_ = keyid;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.keyId)
}

// optional .proto.ExitCode exitCode = 7;
inline bool SyncdPatch::_internal_has_exitcode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.exitcode_ != nullptr);
  return value;
}
inline bool SyncdPatch::has_exitcode() const {
  return _internal_has_exitcode();
}
inline void SyncdPatch::clear_exitcode() {
  if (_impl_.exitcode_ != nullptr) _impl_.exitcode_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::proto::ExitCode& SyncdPatch::_internal_exitcode() const {
  const ::proto::ExitCode* p = _impl_.exitcode_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::ExitCode&>(
      ::proto::_ExitCode_default_instance_);
}
inline const ::proto::ExitCode& SyncdPatch::exitcode() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.exitCode)
  return _internal_exitcode();
}
inline void SyncdPatch::unsafe_arena_set_allocated_exitcode(
    ::proto::ExitCode* exitcode) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exitcode_);
  }
  _impl_.exitcode_ = exitcode;
  if (exitcode) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdPatch.exitCode)
}
inline ::proto::ExitCode* SyncdPatch::release_exitcode() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ExitCode* temp = _impl_.exitcode_;
  _impl_.exitcode_ = 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 ::proto::ExitCode* SyncdPatch::unsafe_arena_release_exitcode() {
  // @@protoc_insertion_point(field_release:proto.SyncdPatch.exitCode)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::proto::ExitCode* temp = _impl_.exitcode_;
  _impl_.exitcode_ = nullptr;
  return temp;
}
inline ::proto::ExitCode* SyncdPatch::_internal_mutable_exitcode() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.exitcode_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::ExitCode>(GetArenaForAllocation());
    _impl_.exitcode_ = p;
  }
  return _impl_.exitcode_;
}
inline ::proto::ExitCode* SyncdPatch::mutable_exitcode() {
  ::proto::ExitCode* _msg = _internal_mutable_exitcode();
  // @@protoc_insertion_point(field_mutable:proto.SyncdPatch.exitCode)
  return _msg;
}
inline void SyncdPatch::set_allocated_exitcode(::proto::ExitCode* exitcode) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.exitcode_;
  }
  if (exitcode) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exitcode);
    if (message_arena != submessage_arena) {
      exitcode = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, exitcode, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.exitcode_ = exitcode;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdPatch.exitCode)
}

// optional uint32 deviceIndex = 8;
inline bool SyncdPatch::_internal_has_deviceindex() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SyncdPatch::has_deviceindex() const {
  return _internal_has_deviceindex();
}
inline void SyncdPatch::clear_deviceindex() {
  _impl_.deviceindex_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t SyncdPatch::_internal_deviceindex() const {
  return _impl_.deviceindex_;
}
inline uint32_t SyncdPatch::deviceindex() const {
  // @@protoc_insertion_point(field_get:proto.SyncdPatch.deviceIndex)
  return _internal_deviceindex();
}
inline void SyncdPatch::_internal_set_deviceindex(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.deviceindex_ = value;
}
inline void SyncdPatch::set_deviceindex(uint32_t value) {
  _internal_set_deviceindex(value);
  // @@protoc_insertion_point(field_set:proto.SyncdPatch.deviceIndex)
}

// -------------------------------------------------------------------

// SyncdRecord

// optional .proto.SyncdIndex index = 1;
inline bool SyncdRecord::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.index_ != nullptr);
  return value;
}
inline bool SyncdRecord::has_index() const {
  return _internal_has_index();
}
inline void SyncdRecord::clear_index() {
  if (_impl_.index_ != nullptr) _impl_.index_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::SyncdIndex& SyncdRecord::_internal_index() const {
  const ::proto::SyncdIndex* p = _impl_.index_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdIndex&>(
      ::proto::_SyncdIndex_default_instance_);
}
inline const ::proto::SyncdIndex& SyncdRecord::index() const {
  // @@protoc_insertion_point(field_get:proto.SyncdRecord.index)
  return _internal_index();
}
inline void SyncdRecord::unsafe_arena_set_allocated_index(
    ::proto::SyncdIndex* index) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.index_);
  }
  _impl_.index_ = index;
  if (index) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.index)
}
inline ::proto::SyncdIndex* SyncdRecord::release_index() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncdIndex* temp = _impl_.index_;
  _impl_.index_ = 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 ::proto::SyncdIndex* SyncdRecord::unsafe_arena_release_index() {
  // @@protoc_insertion_point(field_release:proto.SyncdRecord.index)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::SyncdIndex* temp = _impl_.index_;
  _impl_.index_ = nullptr;
  return temp;
}
inline ::proto::SyncdIndex* SyncdRecord::_internal_mutable_index() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.index_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncdIndex>(GetArenaForAllocation());
    _impl_.index_ = p;
  }
  return _impl_.index_;
}
inline ::proto::SyncdIndex* SyncdRecord::mutable_index() {
  ::proto::SyncdIndex* _msg = _internal_mutable_index();
  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.index)
  return _msg;
}
inline void SyncdRecord::set_allocated_index(::proto::SyncdIndex* index) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.index_;
  }
  if (index) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index);
    if (message_arena != submessage_arena) {
      index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, index, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.index_ = index;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.index)
}

// optional .proto.SyncdValue value = 2;
inline bool SyncdRecord::_internal_has_value() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.value_ != nullptr);
  return value;
}
inline bool SyncdRecord::has_value() const {
  return _internal_has_value();
}
inline void SyncdRecord::clear_value() {
  if (_impl_.value_ != nullptr) _impl_.value_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::SyncdValue& SyncdRecord::_internal_value() const {
  const ::proto::SyncdValue* p = _impl_.value_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdValue&>(
      ::proto::_SyncdValue_default_instance_);
}
inline const ::proto::SyncdValue& SyncdRecord::value() const {
  // @@protoc_insertion_point(field_get:proto.SyncdRecord.value)
  return _internal_value();
}
inline void SyncdRecord::unsafe_arena_set_allocated_value(
    ::proto::SyncdValue* value) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.value_);
  }
  _impl_.value_ = value;
  if (value) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.value)
}
inline ::proto::SyncdValue* SyncdRecord::release_value() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncdValue* temp = _impl_.value_;
  _impl_.value_ = 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 ::proto::SyncdValue* SyncdRecord::unsafe_arena_release_value() {
  // @@protoc_insertion_point(field_release:proto.SyncdRecord.value)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncdValue* temp = _impl_.value_;
  _impl_.value_ = nullptr;
  return temp;
}
inline ::proto::SyncdValue* SyncdRecord::_internal_mutable_value() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.value_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncdValue>(GetArenaForAllocation());
    _impl_.value_ = p;
  }
  return _impl_.value_;
}
inline ::proto::SyncdValue* SyncdRecord::mutable_value() {
  ::proto::SyncdValue* _msg = _internal_mutable_value();
  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.value)
  return _msg;
}
inline void SyncdRecord::set_allocated_value(::proto::SyncdValue* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.value_;
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value);
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.value_ = value;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.value)
}

// optional .proto.KeyId keyId = 3;
inline bool SyncdRecord::_internal_has_keyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
  return value;
}
inline bool SyncdRecord::has_keyid() const {
  return _internal_has_keyid();
}
inline void SyncdRecord::clear_keyid() {
  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::KeyId& SyncdRecord::_internal_keyid() const {
  const ::proto::KeyId* p = _impl_.keyid_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
      ::proto::_KeyId_default_instance_);
}
inline const ::proto::KeyId& SyncdRecord::keyid() const {
  // @@protoc_insertion_point(field_get:proto.SyncdRecord.keyId)
  return _internal_keyid();
}
inline void SyncdRecord::unsafe_arena_set_allocated_keyid(
    ::proto::KeyId* keyid) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
  }
  _impl_.keyid_ = keyid;
  if (keyid) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdRecord.keyId)
}
inline ::proto::KeyId* SyncdRecord::release_keyid() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = 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 ::proto::KeyId* SyncdRecord::unsafe_arena_release_keyid() {
  // @@protoc_insertion_point(field_release:proto.SyncdRecord.keyId)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = nullptr;
  return temp;
}
inline ::proto::KeyId* SyncdRecord::_internal_mutable_keyid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.keyid_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
    _impl_.keyid_ = p;
  }
  return _impl_.keyid_;
}
inline ::proto::KeyId* SyncdRecord::mutable_keyid() {
  ::proto::KeyId* _msg = _internal_mutable_keyid();
  // @@protoc_insertion_point(field_mutable:proto.SyncdRecord.keyId)
  return _msg;
}
inline void SyncdRecord::set_allocated_keyid(::proto::KeyId* keyid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keyid_;
  }
  if (keyid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
    if (message_arena != submessage_arena) {
      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keyid, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.keyid_ = keyid;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdRecord.keyId)
}

// -------------------------------------------------------------------

// SyncdSnapshot

// optional .proto.SyncdVersion version = 1;
inline bool SyncdSnapshot::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.version_ != nullptr);
  return value;
}
inline bool SyncdSnapshot::has_version() const {
  return _internal_has_version();
}
inline void SyncdSnapshot::clear_version() {
  if (_impl_.version_ != nullptr) _impl_.version_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::SyncdVersion& SyncdSnapshot::_internal_version() const {
  const ::proto::SyncdVersion* p = _impl_.version_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::SyncdVersion&>(
      ::proto::_SyncdVersion_default_instance_);
}
inline const ::proto::SyncdVersion& SyncdSnapshot::version() const {
  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.version)
  return _internal_version();
}
inline void SyncdSnapshot::unsafe_arena_set_allocated_version(
    ::proto::SyncdVersion* version) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
  }
  _impl_.version_ = version;
  if (version) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.version)
}
inline ::proto::SyncdVersion* SyncdSnapshot::release_version() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncdVersion* temp = _impl_.version_;
  _impl_.version_ = 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 ::proto::SyncdVersion* SyncdSnapshot::unsafe_arena_release_version() {
  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.version)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::SyncdVersion* temp = _impl_.version_;
  _impl_.version_ = nullptr;
  return temp;
}
inline ::proto::SyncdVersion* SyncdSnapshot::_internal_mutable_version() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.version_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::SyncdVersion>(GetArenaForAllocation());
    _impl_.version_ = p;
  }
  return _impl_.version_;
}
inline ::proto::SyncdVersion* SyncdSnapshot::mutable_version() {
  ::proto::SyncdVersion* _msg = _internal_mutable_version();
  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.version)
  return _msg;
}
inline void SyncdSnapshot::set_allocated_version(::proto::SyncdVersion* version) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.version_;
  }
  if (version) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(version);
    if (message_arena != submessage_arena) {
      version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, version, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.version_ = version;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.version)
}

// repeated .proto.SyncdRecord records = 2;
inline int SyncdSnapshot::_internal_records_size() const {
  return _impl_.records_.size();
}
inline int SyncdSnapshot::records_size() const {
  return _internal_records_size();
}
inline void SyncdSnapshot::clear_records() {
  _impl_.records_.Clear();
}
inline ::proto::SyncdRecord* SyncdSnapshot::mutable_records(int index) {
  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.records)
  return _impl_.records_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >*
SyncdSnapshot::mutable_records() {
  // @@protoc_insertion_point(field_mutable_list:proto.SyncdSnapshot.records)
  return &_impl_.records_;
}
inline const ::proto::SyncdRecord& SyncdSnapshot::_internal_records(int index) const {
  return _impl_.records_.Get(index);
}
inline const ::proto::SyncdRecord& SyncdSnapshot::records(int index) const {
  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.records)
  return _internal_records(index);
}
inline ::proto::SyncdRecord* SyncdSnapshot::_internal_add_records() {
  return _impl_.records_.Add();
}
inline ::proto::SyncdRecord* SyncdSnapshot::add_records() {
  ::proto::SyncdRecord* _add = _internal_add_records();
  // @@protoc_insertion_point(field_add:proto.SyncdSnapshot.records)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::SyncdRecord >&
SyncdSnapshot::records() const {
  // @@protoc_insertion_point(field_list:proto.SyncdSnapshot.records)
  return _impl_.records_;
}

// optional bytes mac = 3;
inline bool SyncdSnapshot::_internal_has_mac() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncdSnapshot::has_mac() const {
  return _internal_has_mac();
}
inline void SyncdSnapshot::clear_mac() {
  _impl_.mac_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncdSnapshot::mac() const {
  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.mac)
  return _internal_mac();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncdSnapshot::set_mac(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.mac_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncdSnapshot.mac)
}
inline std::string* SyncdSnapshot::mutable_mac() {
  std::string* _s = _internal_mutable_mac();
  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.mac)
  return _s;
}
inline const std::string& SyncdSnapshot::_internal_mac() const {
  return _impl_.mac_.Get();
}
inline void SyncdSnapshot::_internal_set_mac(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.mac_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncdSnapshot::_internal_mutable_mac() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.mac_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncdSnapshot::release_mac() {
  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.mac)
  if (!_internal_has_mac()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.mac_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mac_.IsDefault()) {
    _impl_.mac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncdSnapshot::set_allocated_mac(std::string* mac) {
  if (mac != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.mac_.SetAllocated(mac, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mac_.IsDefault()) {
    _impl_.mac_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.mac)
}

// optional .proto.KeyId keyId = 4;
inline bool SyncdSnapshot::_internal_has_keyid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keyid_ != nullptr);
  return value;
}
inline bool SyncdSnapshot::has_keyid() const {
  return _internal_has_keyid();
}
inline void SyncdSnapshot::clear_keyid() {
  if (_impl_.keyid_ != nullptr) _impl_.keyid_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::proto::KeyId& SyncdSnapshot::_internal_keyid() const {
  const ::proto::KeyId* p = _impl_.keyid_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeyId&>(
      ::proto::_KeyId_default_instance_);
}
inline const ::proto::KeyId& SyncdSnapshot::keyid() const {
  // @@protoc_insertion_point(field_get:proto.SyncdSnapshot.keyId)
  return _internal_keyid();
}
inline void SyncdSnapshot::unsafe_arena_set_allocated_keyid(
    ::proto::KeyId* keyid) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keyid_);
  }
  _impl_.keyid_ = keyid;
  if (keyid) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.SyncdSnapshot.keyId)
}
inline ::proto::KeyId* SyncdSnapshot::release_keyid() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = 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 ::proto::KeyId* SyncdSnapshot::unsafe_arena_release_keyid() {
  // @@protoc_insertion_point(field_release:proto.SyncdSnapshot.keyId)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::proto::KeyId* temp = _impl_.keyid_;
  _impl_.keyid_ = nullptr;
  return temp;
}
inline ::proto::KeyId* SyncdSnapshot::_internal_mutable_keyid() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.keyid_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::KeyId>(GetArenaForAllocation());
    _impl_.keyid_ = p;
  }
  return _impl_.keyid_;
}
inline ::proto::KeyId* SyncdSnapshot::mutable_keyid() {
  ::proto::KeyId* _msg = _internal_mutable_keyid();
  // @@protoc_insertion_point(field_mutable:proto.SyncdSnapshot.keyId)
  return _msg;
}
inline void SyncdSnapshot::set_allocated_keyid(::proto::KeyId* keyid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keyid_;
  }
  if (keyid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keyid);
    if (message_arena != submessage_arena) {
      keyid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keyid, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.keyid_ = keyid;
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdSnapshot.keyId)
}

// -------------------------------------------------------------------

// SyncdValue

// optional bytes blob = 1;
inline bool SyncdValue::_internal_has_blob() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncdValue::has_blob() const {
  return _internal_has_blob();
}
inline void SyncdValue::clear_blob() {
  _impl_.blob_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SyncdValue::blob() const {
  // @@protoc_insertion_point(field_get:proto.SyncdValue.blob)
  return _internal_blob();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SyncdValue::set_blob(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.blob_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.SyncdValue.blob)
}
inline std::string* SyncdValue::mutable_blob() {
  std::string* _s = _internal_mutable_blob();
  // @@protoc_insertion_point(field_mutable:proto.SyncdValue.blob)
  return _s;
}
inline const std::string& SyncdValue::_internal_blob() const {
  return _impl_.blob_.Get();
}
inline void SyncdValue::_internal_set_blob(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.blob_.Set(value, GetArenaForAllocation());
}
inline std::string* SyncdValue::_internal_mutable_blob() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.blob_.Mutable(GetArenaForAllocation());
}
inline std::string* SyncdValue::release_blob() {
  // @@protoc_insertion_point(field_release:proto.SyncdValue.blob)
  if (!_internal_has_blob()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.blob_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.blob_.IsDefault()) {
    _impl_.blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SyncdValue::set_allocated_blob(std::string* blob) {
  if (blob != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.blob_.SetAllocated(blob, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.blob_.IsDefault()) {
    _impl_.blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.SyncdValue.blob)
}

// -------------------------------------------------------------------

// SyncdVersion

// optional uint64 version = 1;
inline bool SyncdVersion::_internal_has_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SyncdVersion::has_version() const {
  return _internal_has_version();
}
inline void SyncdVersion::clear_version() {
  _impl_.version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t SyncdVersion::_internal_version() const {
  return _impl_.version_;
}
inline uint64_t SyncdVersion::version() const {
  // @@protoc_insertion_point(field_get:proto.SyncdVersion.version)
  return _internal_version();
}
inline void SyncdVersion::_internal_set_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.version_ = value;
}
inline void SyncdVersion::set_version(uint64_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:proto.SyncdVersion.version)
}

// -------------------------------------------------------------------

// TemplateButton_CallButton

// optional .proto.Message.HighlyStructuredMessage displayText = 1;
inline bool TemplateButton_CallButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
  return value;
}
inline bool TemplateButton_CallButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void TemplateButton_CallButton::clear_displaytext() {
  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_displaytext() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.displayText)
  return _internal_displaytext();
}
inline void TemplateButton_CallButton::unsafe_arena_set_allocated_displaytext(
    ::proto::Message_HighlyStructuredMessage* displaytext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
  }
  _impl_.displaytext_ = displaytext;
  if (displaytext) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.displayText)
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_displaytext() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = 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 ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.displayText)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.displaytext_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.displaytext_ = p;
  }
  return _impl_.displaytext_;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_displaytext() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.displayText)
  return _msg;
}
inline void TemplateButton_CallButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.displaytext_;
  }
  if (displaytext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
    if (message_arena != submessage_arena) {
      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, displaytext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_ = displaytext;
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.displayText)
}

// optional .proto.Message.HighlyStructuredMessage phoneNumber = 2;
inline bool TemplateButton_CallButton::_internal_has_phonenumber() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.phonenumber_ != nullptr);
  return value;
}
inline bool TemplateButton_CallButton::has_phonenumber() const {
  return _internal_has_phonenumber();
}
inline void TemplateButton_CallButton::clear_phonenumber() {
  if (_impl_.phonenumber_ != nullptr) _impl_.phonenumber_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::_internal_phonenumber() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.phonenumber_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_CallButton::phonenumber() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.CallButton.phoneNumber)
  return _internal_phonenumber();
}
inline void TemplateButton_CallButton::unsafe_arena_set_allocated_phonenumber(
    ::proto::Message_HighlyStructuredMessage* phonenumber) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.phonenumber_);
  }
  _impl_.phonenumber_ = phonenumber;
  if (phonenumber) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.CallButton.phoneNumber)
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::release_phonenumber() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_;
  _impl_.phonenumber_ = 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 ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::unsafe_arena_release_phonenumber() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.CallButton.phoneNumber)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.phonenumber_;
  _impl_.phonenumber_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::_internal_mutable_phonenumber() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.phonenumber_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.phonenumber_ = p;
  }
  return _impl_.phonenumber_;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_CallButton::mutable_phonenumber() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_phonenumber();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.CallButton.phoneNumber)
  return _msg;
}
inline void TemplateButton_CallButton::set_allocated_phonenumber(::proto::Message_HighlyStructuredMessage* phonenumber) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.phonenumber_;
  }
  if (phonenumber) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(phonenumber);
    if (message_arena != submessage_arena) {
      phonenumber = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, phonenumber, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.phonenumber_ = phonenumber;
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.CallButton.phoneNumber)
}

// -------------------------------------------------------------------

// TemplateButton_QuickReplyButton

// optional .proto.Message.HighlyStructuredMessage displayText = 1;
inline bool TemplateButton_QuickReplyButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
  return value;
}
inline bool TemplateButton_QuickReplyButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void TemplateButton_QuickReplyButton::clear_displaytext() {
  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::_internal_displaytext() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_QuickReplyButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.displayText)
  return _internal_displaytext();
}
inline void TemplateButton_QuickReplyButton::unsafe_arena_set_allocated_displaytext(
    ::proto::Message_HighlyStructuredMessage* displaytext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
  }
  _impl_.displaytext_ = displaytext;
  if (displaytext) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.QuickReplyButton.displayText)
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::release_displaytext() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = 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 ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::unsafe_arena_release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.displayText)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.displaytext_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.displaytext_ = p;
  }
  return _impl_.displaytext_;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_QuickReplyButton::mutable_displaytext() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.displayText)
  return _msg;
}
inline void TemplateButton_QuickReplyButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.displaytext_;
  }
  if (displaytext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
    if (message_arena != submessage_arena) {
      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, displaytext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.displaytext_ = displaytext;
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.displayText)
}

// optional string id = 2;
inline bool TemplateButton_QuickReplyButton::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TemplateButton_QuickReplyButton::has_id() const {
  return _internal_has_id();
}
inline void TemplateButton_QuickReplyButton::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TemplateButton_QuickReplyButton::id() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.QuickReplyButton.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void TemplateButton_QuickReplyButton::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.TemplateButton.QuickReplyButton.id)
}
inline std::string* TemplateButton_QuickReplyButton::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.QuickReplyButton.id)
  return _s;
}
inline const std::string& TemplateButton_QuickReplyButton::_internal_id() const {
  return _impl_.id_.Get();
}
inline void TemplateButton_QuickReplyButton::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* TemplateButton_QuickReplyButton::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* TemplateButton_QuickReplyButton::release_id() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.QuickReplyButton.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void TemplateButton_QuickReplyButton::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.QuickReplyButton.id)
}

// -------------------------------------------------------------------

// TemplateButton_URLButton

// optional .proto.Message.HighlyStructuredMessage displayText = 1;
inline bool TemplateButton_URLButton::_internal_has_displaytext() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.displaytext_ != nullptr);
  return value;
}
inline bool TemplateButton_URLButton::has_displaytext() const {
  return _internal_has_displaytext();
}
inline void TemplateButton_URLButton::clear_displaytext() {
  if (_impl_.displaytext_ != nullptr) _impl_.displaytext_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_displaytext() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.displaytext_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::displaytext() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.displayText)
  return _internal_displaytext();
}
inline void TemplateButton_URLButton::unsafe_arena_set_allocated_displaytext(
    ::proto::Message_HighlyStructuredMessage* displaytext) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.displaytext_);
  }
  _impl_.displaytext_ = displaytext;
  if (displaytext) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.displayText)
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_displaytext() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = 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 ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_displaytext() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.displayText)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.displaytext_;
  _impl_.displaytext_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_displaytext() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.displaytext_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.displaytext_ = p;
  }
  return _impl_.displaytext_;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_displaytext() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_displaytext();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.displayText)
  return _msg;
}
inline void TemplateButton_URLButton::set_allocated_displaytext(::proto::Message_HighlyStructuredMessage* displaytext) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.displaytext_;
  }
  if (displaytext) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(displaytext);
    if (message_arena != submessage_arena) {
      displaytext = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, displaytext, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.displaytext_ = displaytext;
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.displayText)
}

// optional .proto.Message.HighlyStructuredMessage url = 2;
inline bool TemplateButton_URLButton::_internal_has_url() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.url_ != nullptr);
  return value;
}
inline bool TemplateButton_URLButton::has_url() const {
  return _internal_has_url();
}
inline void TemplateButton_URLButton::clear_url() {
  if (_impl_.url_ != nullptr) _impl_.url_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::_internal_url() const {
  const ::proto::Message_HighlyStructuredMessage* p = _impl_.url_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_HighlyStructuredMessage&>(
      ::proto::_Message_HighlyStructuredMessage_default_instance_);
}
inline const ::proto::Message_HighlyStructuredMessage& TemplateButton_URLButton::url() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.URLButton.url)
  return _internal_url();
}
inline void TemplateButton_URLButton::unsafe_arena_set_allocated_url(
    ::proto::Message_HighlyStructuredMessage* url) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.url_);
  }
  _impl_.url_ = url;
  if (url) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.URLButton.url)
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::release_url() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_;
  _impl_.url_ = 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 ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::unsafe_arena_release_url() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.URLButton.url)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::proto::Message_HighlyStructuredMessage* temp = _impl_.url_;
  _impl_.url_ = nullptr;
  return temp;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::_internal_mutable_url() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.url_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_HighlyStructuredMessage>(GetArenaForAllocation());
    _impl_.url_ = p;
  }
  return _impl_.url_;
}
inline ::proto::Message_HighlyStructuredMessage* TemplateButton_URLButton::mutable_url() {
  ::proto::Message_HighlyStructuredMessage* _msg = _internal_mutable_url();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.URLButton.url)
  return _msg;
}
inline void TemplateButton_URLButton::set_allocated_url(::proto::Message_HighlyStructuredMessage* url) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.url_;
  }
  if (url) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(url);
    if (message_arena != submessage_arena) {
      url = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, url, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.url_ = url;
  // @@protoc_insertion_point(field_set_allocated:proto.TemplateButton.URLButton.url)
}

// -------------------------------------------------------------------

// TemplateButton

// optional uint32 index = 4;
inline bool TemplateButton::_internal_has_index() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool TemplateButton::has_index() const {
  return _internal_has_index();
}
inline void TemplateButton::clear_index() {
  _impl_.index_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t TemplateButton::_internal_index() const {
  return _impl_.index_;
}
inline uint32_t TemplateButton::index() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.index)
  return _internal_index();
}
inline void TemplateButton::_internal_set_index(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.index_ = value;
}
inline void TemplateButton::set_index(uint32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:proto.TemplateButton.index)
}

// .proto.TemplateButton.QuickReplyButton quickReplyButton = 1;
inline bool TemplateButton::_internal_has_quickreplybutton() const {
  return button_case() == kQuickReplyButton;
}
inline bool TemplateButton::has_quickreplybutton() const {
  return _internal_has_quickreplybutton();
}
inline void TemplateButton::set_has_quickreplybutton() {
  _impl_._oneof_case_[0] = kQuickReplyButton;
}
inline void TemplateButton::clear_quickreplybutton() {
  if (_internal_has_quickreplybutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.button_.quickreplybutton_;
    }
    clear_has_button();
  }
}
inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::release_quickreplybutton() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.quickReplyButton)
  if (_internal_has_quickreplybutton()) {
    clear_has_button();
    ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.button_.quickreplybutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::_internal_quickreplybutton() const {
  return _internal_has_quickreplybutton()
      ? *_impl_.button_.quickreplybutton_
      : reinterpret_cast< ::proto::TemplateButton_QuickReplyButton&>(::proto::_TemplateButton_QuickReplyButton_default_instance_);
}
inline const ::proto::TemplateButton_QuickReplyButton& TemplateButton::quickreplybutton() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.quickReplyButton)
  return _internal_quickreplybutton();
}
inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::unsafe_arena_release_quickreplybutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.quickReplyButton)
  if (_internal_has_quickreplybutton()) {
    clear_has_button();
    ::proto::TemplateButton_QuickReplyButton* temp = _impl_.button_.quickreplybutton_;
    _impl_.button_.quickreplybutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TemplateButton::unsafe_arena_set_allocated_quickreplybutton(::proto::TemplateButton_QuickReplyButton* quickreplybutton) {
  clear_button();
  if (quickreplybutton) {
    set_has_quickreplybutton();
    _impl_.button_.quickreplybutton_ = quickreplybutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.quickReplyButton)
}
inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::_internal_mutable_quickreplybutton() {
  if (!_internal_has_quickreplybutton()) {
    clear_button();
    set_has_quickreplybutton();
    _impl_.button_.quickreplybutton_ = CreateMaybeMessage< ::proto::TemplateButton_QuickReplyButton >(GetArenaForAllocation());
  }
  return _impl_.button_.quickreplybutton_;
}
inline ::proto::TemplateButton_QuickReplyButton* TemplateButton::mutable_quickreplybutton() {
  ::proto::TemplateButton_QuickReplyButton* _msg = _internal_mutable_quickreplybutton();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.quickReplyButton)
  return _msg;
}

// .proto.TemplateButton.URLButton urlButton = 2;
inline bool TemplateButton::_internal_has_urlbutton() const {
  return button_case() == kUrlButton;
}
inline bool TemplateButton::has_urlbutton() const {
  return _internal_has_urlbutton();
}
inline void TemplateButton::set_has_urlbutton() {
  _impl_._oneof_case_[0] = kUrlButton;
}
inline void TemplateButton::clear_urlbutton() {
  if (_internal_has_urlbutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.button_.urlbutton_;
    }
    clear_has_button();
  }
}
inline ::proto::TemplateButton_URLButton* TemplateButton::release_urlbutton() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.urlButton)
  if (_internal_has_urlbutton()) {
    clear_has_button();
    ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.button_.urlbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::TemplateButton_URLButton& TemplateButton::_internal_urlbutton() const {
  return _internal_has_urlbutton()
      ? *_impl_.button_.urlbutton_
      : reinterpret_cast< ::proto::TemplateButton_URLButton&>(::proto::_TemplateButton_URLButton_default_instance_);
}
inline const ::proto::TemplateButton_URLButton& TemplateButton::urlbutton() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.urlButton)
  return _internal_urlbutton();
}
inline ::proto::TemplateButton_URLButton* TemplateButton::unsafe_arena_release_urlbutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.urlButton)
  if (_internal_has_urlbutton()) {
    clear_has_button();
    ::proto::TemplateButton_URLButton* temp = _impl_.button_.urlbutton_;
    _impl_.button_.urlbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TemplateButton::unsafe_arena_set_allocated_urlbutton(::proto::TemplateButton_URLButton* urlbutton) {
  clear_button();
  if (urlbutton) {
    set_has_urlbutton();
    _impl_.button_.urlbutton_ = urlbutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.urlButton)
}
inline ::proto::TemplateButton_URLButton* TemplateButton::_internal_mutable_urlbutton() {
  if (!_internal_has_urlbutton()) {
    clear_button();
    set_has_urlbutton();
    _impl_.button_.urlbutton_ = CreateMaybeMessage< ::proto::TemplateButton_URLButton >(GetArenaForAllocation());
  }
  return _impl_.button_.urlbutton_;
}
inline ::proto::TemplateButton_URLButton* TemplateButton::mutable_urlbutton() {
  ::proto::TemplateButton_URLButton* _msg = _internal_mutable_urlbutton();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.urlButton)
  return _msg;
}

// .proto.TemplateButton.CallButton callButton = 3;
inline bool TemplateButton::_internal_has_callbutton() const {
  return button_case() == kCallButton;
}
inline bool TemplateButton::has_callbutton() const {
  return _internal_has_callbutton();
}
inline void TemplateButton::set_has_callbutton() {
  _impl_._oneof_case_[0] = kCallButton;
}
inline void TemplateButton::clear_callbutton() {
  if (_internal_has_callbutton()) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.button_.callbutton_;
    }
    clear_has_button();
  }
}
inline ::proto::TemplateButton_CallButton* TemplateButton::release_callbutton() {
  // @@protoc_insertion_point(field_release:proto.TemplateButton.callButton)
  if (_internal_has_callbutton()) {
    clear_has_button();
    ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    _impl_.button_.callbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::proto::TemplateButton_CallButton& TemplateButton::_internal_callbutton() const {
  return _internal_has_callbutton()
      ? *_impl_.button_.callbutton_
      : reinterpret_cast< ::proto::TemplateButton_CallButton&>(::proto::_TemplateButton_CallButton_default_instance_);
}
inline const ::proto::TemplateButton_CallButton& TemplateButton::callbutton() const {
  // @@protoc_insertion_point(field_get:proto.TemplateButton.callButton)
  return _internal_callbutton();
}
inline ::proto::TemplateButton_CallButton* TemplateButton::unsafe_arena_release_callbutton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:proto.TemplateButton.callButton)
  if (_internal_has_callbutton()) {
    clear_has_button();
    ::proto::TemplateButton_CallButton* temp = _impl_.button_.callbutton_;
    _impl_.button_.callbutton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void TemplateButton::unsafe_arena_set_allocated_callbutton(::proto::TemplateButton_CallButton* callbutton) {
  clear_button();
  if (callbutton) {
    set_has_callbutton();
    _impl_.button_.callbutton_ = callbutton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.TemplateButton.callButton)
}
inline ::proto::TemplateButton_CallButton* TemplateButton::_internal_mutable_callbutton() {
  if (!_internal_has_callbutton()) {
    clear_button();
    set_has_callbutton();
    _impl_.button_.callbutton_ = CreateMaybeMessage< ::proto::TemplateButton_CallButton >(GetArenaForAllocation());
  }
  return _impl_.button_.callbutton_;
}
inline ::proto::TemplateButton_CallButton* TemplateButton::mutable_callbutton() {
  ::proto::TemplateButton_CallButton* _msg = _internal_mutable_callbutton();
  // @@protoc_insertion_point(field_mutable:proto.TemplateButton.callButton)
  return _msg;
}

inline bool TemplateButton::has_button() const {
  return button_case() != BUTTON_NOT_SET;
}
inline void TemplateButton::clear_has_button() {
  _impl_._oneof_case_[0] = BUTTON_NOT_SET;
}
inline TemplateButton::ButtonCase TemplateButton::button_case() const {
  return TemplateButton::ButtonCase(_impl_._oneof_case_[0]);
}
// -------------------------------------------------------------------

// UserReceipt

// required string userJid = 1;
inline bool UserReceipt::_internal_has_userjid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool UserReceipt::has_userjid() const {
  return _internal_has_userjid();
}
inline void UserReceipt::clear_userjid() {
  _impl_.userjid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& UserReceipt::userjid() const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.userJid)
  return _internal_userjid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void UserReceipt::set_userjid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.userjid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.UserReceipt.userJid)
}
inline std::string* UserReceipt::mutable_userjid() {
  std::string* _s = _internal_mutable_userjid();
  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.userJid)
  return _s;
}
inline const std::string& UserReceipt::_internal_userjid() const {
  return _impl_.userjid_.Get();
}
inline void UserReceipt::_internal_set_userjid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.userjid_.Set(value, GetArenaForAllocation());
}
inline std::string* UserReceipt::_internal_mutable_userjid() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.userjid_.Mutable(GetArenaForAllocation());
}
inline std::string* UserReceipt::release_userjid() {
  // @@protoc_insertion_point(field_release:proto.UserReceipt.userJid)
  if (!_internal_has_userjid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.userjid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void UserReceipt::set_allocated_userjid(std::string* userjid) {
  if (userjid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.userjid_.SetAllocated(userjid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.userjid_.IsDefault()) {
    _impl_.userjid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.UserReceipt.userJid)
}

// optional int64 receiptTimestamp = 2;
inline bool UserReceipt::_internal_has_receipttimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool UserReceipt::has_receipttimestamp() const {
  return _internal_has_receipttimestamp();
}
inline void UserReceipt::clear_receipttimestamp() {
  _impl_.receipttimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline int64_t UserReceipt::_internal_receipttimestamp() const {
  return _impl_.receipttimestamp_;
}
inline int64_t UserReceipt::receipttimestamp() const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.receiptTimestamp)
  return _internal_receipttimestamp();
}
inline void UserReceipt::_internal_set_receipttimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.receipttimestamp_ = value;
}
inline void UserReceipt::set_receipttimestamp(int64_t value) {
  _internal_set_receipttimestamp(value);
  // @@protoc_insertion_point(field_set:proto.UserReceipt.receiptTimestamp)
}

// optional int64 readTimestamp = 3;
inline bool UserReceipt::_internal_has_readtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool UserReceipt::has_readtimestamp() const {
  return _internal_has_readtimestamp();
}
inline void UserReceipt::clear_readtimestamp() {
  _impl_.readtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline int64_t UserReceipt::_internal_readtimestamp() const {
  return _impl_.readtimestamp_;
}
inline int64_t UserReceipt::readtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.readTimestamp)
  return _internal_readtimestamp();
}
inline void UserReceipt::_internal_set_readtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.readtimestamp_ = value;
}
inline void UserReceipt::set_readtimestamp(int64_t value) {
  _internal_set_readtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.UserReceipt.readTimestamp)
}

// optional int64 playedTimestamp = 4;
inline bool UserReceipt::_internal_has_playedtimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool UserReceipt::has_playedtimestamp() const {
  return _internal_has_playedtimestamp();
}
inline void UserReceipt::clear_playedtimestamp() {
  _impl_.playedtimestamp_ = int64_t{0};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline int64_t UserReceipt::_internal_playedtimestamp() const {
  return _impl_.playedtimestamp_;
}
inline int64_t UserReceipt::playedtimestamp() const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.playedTimestamp)
  return _internal_playedtimestamp();
}
inline void UserReceipt::_internal_set_playedtimestamp(int64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.playedtimestamp_ = value;
}
inline void UserReceipt::set_playedtimestamp(int64_t value) {
  _internal_set_playedtimestamp(value);
  // @@protoc_insertion_point(field_set:proto.UserReceipt.playedTimestamp)
}

// repeated string pendingDeviceJid = 5;
inline int UserReceipt::_internal_pendingdevicejid_size() const {
  return _impl_.pendingdevicejid_.size();
}
inline int UserReceipt::pendingdevicejid_size() const {
  return _internal_pendingdevicejid_size();
}
inline void UserReceipt::clear_pendingdevicejid() {
  _impl_.pendingdevicejid_.Clear();
}
inline std::string* UserReceipt::add_pendingdevicejid() {
  std::string* _s = _internal_add_pendingdevicejid();
  // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.pendingDeviceJid)
  return _s;
}
inline const std::string& UserReceipt::_internal_pendingdevicejid(int index) const {
  return _impl_.pendingdevicejid_.Get(index);
}
inline const std::string& UserReceipt::pendingdevicejid(int index) const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.pendingDeviceJid)
  return _internal_pendingdevicejid(index);
}
inline std::string* UserReceipt::mutable_pendingdevicejid(int index) {
  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.pendingDeviceJid)
  return _impl_.pendingdevicejid_.Mutable(index);
}
inline void UserReceipt::set_pendingdevicejid(int index, const std::string& value) {
  _impl_.pendingdevicejid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::set_pendingdevicejid(int index, std::string&& value) {
  _impl_.pendingdevicejid_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::set_pendingdevicejid(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.pendingdevicejid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::set_pendingdevicejid(int index, const char* value, size_t size) {
  _impl_.pendingdevicejid_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.pendingDeviceJid)
}
inline std::string* UserReceipt::_internal_add_pendingdevicejid() {
  return _impl_.pendingdevicejid_.Add();
}
inline void UserReceipt::add_pendingdevicejid(const std::string& value) {
  _impl_.pendingdevicejid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::add_pendingdevicejid(std::string&& value) {
  _impl_.pendingdevicejid_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::add_pendingdevicejid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.pendingdevicejid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.UserReceipt.pendingDeviceJid)
}
inline void UserReceipt::add_pendingdevicejid(const char* value, size_t size) {
  _impl_.pendingdevicejid_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.pendingDeviceJid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
UserReceipt::pendingdevicejid() const {
  // @@protoc_insertion_point(field_list:proto.UserReceipt.pendingDeviceJid)
  return _impl_.pendingdevicejid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
UserReceipt::mutable_pendingdevicejid() {
  // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.pendingDeviceJid)
  return &_impl_.pendingdevicejid_;
}

// repeated string deliveredDeviceJid = 6;
inline int UserReceipt::_internal_delivereddevicejid_size() const {
  return _impl_.delivereddevicejid_.size();
}
inline int UserReceipt::delivereddevicejid_size() const {
  return _internal_delivereddevicejid_size();
}
inline void UserReceipt::clear_delivereddevicejid() {
  _impl_.delivereddevicejid_.Clear();
}
inline std::string* UserReceipt::add_delivereddevicejid() {
  std::string* _s = _internal_add_delivereddevicejid();
  // @@protoc_insertion_point(field_add_mutable:proto.UserReceipt.deliveredDeviceJid)
  return _s;
}
inline const std::string& UserReceipt::_internal_delivereddevicejid(int index) const {
  return _impl_.delivereddevicejid_.Get(index);
}
inline const std::string& UserReceipt::delivereddevicejid(int index) const {
  // @@protoc_insertion_point(field_get:proto.UserReceipt.deliveredDeviceJid)
  return _internal_delivereddevicejid(index);
}
inline std::string* UserReceipt::mutable_delivereddevicejid(int index) {
  // @@protoc_insertion_point(field_mutable:proto.UserReceipt.deliveredDeviceJid)
  return _impl_.delivereddevicejid_.Mutable(index);
}
inline void UserReceipt::set_delivereddevicejid(int index, const std::string& value) {
  _impl_.delivereddevicejid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::set_delivereddevicejid(int index, std::string&& value) {
  _impl_.delivereddevicejid_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::set_delivereddevicejid(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.delivereddevicejid_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::set_delivereddevicejid(int index, const char* value, size_t size) {
  _impl_.delivereddevicejid_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.UserReceipt.deliveredDeviceJid)
}
inline std::string* UserReceipt::_internal_add_delivereddevicejid() {
  return _impl_.delivereddevicejid_.Add();
}
inline void UserReceipt::add_delivereddevicejid(const std::string& value) {
  _impl_.delivereddevicejid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::add_delivereddevicejid(std::string&& value) {
  _impl_.delivereddevicejid_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::add_delivereddevicejid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.delivereddevicejid_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.UserReceipt.deliveredDeviceJid)
}
inline void UserReceipt::add_delivereddevicejid(const char* value, size_t size) {
  _impl_.delivereddevicejid_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.UserReceipt.deliveredDeviceJid)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
UserReceipt::delivereddevicejid() const {
  // @@protoc_insertion_point(field_list:proto.UserReceipt.deliveredDeviceJid)
  return _impl_.delivereddevicejid_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
UserReceipt::mutable_delivereddevicejid() {
  // @@protoc_insertion_point(field_mutable_list:proto.UserReceipt.deliveredDeviceJid)
  return &_impl_.delivereddevicejid_;
}

// -------------------------------------------------------------------

// VerifiedNameCertificate_Details

// optional uint64 serial = 1;
inline bool VerifiedNameCertificate_Details::_internal_has_serial() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool VerifiedNameCertificate_Details::has_serial() const {
  return _internal_has_serial();
}
inline void VerifiedNameCertificate_Details::clear_serial() {
  _impl_.serial_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t VerifiedNameCertificate_Details::_internal_serial() const {
  return _impl_.serial_;
}
inline uint64_t VerifiedNameCertificate_Details::serial() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.serial)
  return _internal_serial();
}
inline void VerifiedNameCertificate_Details::_internal_set_serial(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.serial_ = value;
}
inline void VerifiedNameCertificate_Details::set_serial(uint64_t value) {
  _internal_set_serial(value);
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.serial)
}

// optional string issuer = 2;
inline bool VerifiedNameCertificate_Details::_internal_has_issuer() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool VerifiedNameCertificate_Details::has_issuer() const {
  return _internal_has_issuer();
}
inline void VerifiedNameCertificate_Details::clear_issuer() {
  _impl_.issuer_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& VerifiedNameCertificate_Details::issuer() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issuer)
  return _internal_issuer();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerifiedNameCertificate_Details::set_issuer(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.issuer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issuer)
}
inline std::string* VerifiedNameCertificate_Details::mutable_issuer() {
  std::string* _s = _internal_mutable_issuer();
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.issuer)
  return _s;
}
inline const std::string& VerifiedNameCertificate_Details::_internal_issuer() const {
  return _impl_.issuer_.Get();
}
inline void VerifiedNameCertificate_Details::_internal_set_issuer(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.issuer_.Set(value, GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate_Details::_internal_mutable_issuer() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.issuer_.Mutable(GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate_Details::release_issuer() {
  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.issuer)
  if (!_internal_has_issuer()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.issuer_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.issuer_.IsDefault()) {
    _impl_.issuer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void VerifiedNameCertificate_Details::set_allocated_issuer(std::string* issuer) {
  if (issuer != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.issuer_.SetAllocated(issuer, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.issuer_.IsDefault()) {
    _impl_.issuer_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.issuer)
}

// optional string verifiedName = 4;
inline bool VerifiedNameCertificate_Details::_internal_has_verifiedname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool VerifiedNameCertificate_Details::has_verifiedname() const {
  return _internal_has_verifiedname();
}
inline void VerifiedNameCertificate_Details::clear_verifiedname() {
  _impl_.verifiedname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& VerifiedNameCertificate_Details::verifiedname() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.verifiedName)
  return _internal_verifiedname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerifiedNameCertificate_Details::set_verifiedname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.verifiedname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.verifiedName)
}
inline std::string* VerifiedNameCertificate_Details::mutable_verifiedname() {
  std::string* _s = _internal_mutable_verifiedname();
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.verifiedName)
  return _s;
}
inline const std::string& VerifiedNameCertificate_Details::_internal_verifiedname() const {
  return _impl_.verifiedname_.Get();
}
inline void VerifiedNameCertificate_Details::_internal_set_verifiedname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.verifiedname_.Set(value, GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate_Details::_internal_mutable_verifiedname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.verifiedname_.Mutable(GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate_Details::release_verifiedname() {
  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.Details.verifiedName)
  if (!_internal_has_verifiedname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.verifiedname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedname_.IsDefault()) {
    _impl_.verifiedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void VerifiedNameCertificate_Details::set_allocated_verifiedname(std::string* verifiedname) {
  if (verifiedname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.verifiedname_.SetAllocated(verifiedname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedname_.IsDefault()) {
    _impl_.verifiedname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.Details.verifiedName)
}

// repeated .proto.LocalizedName localizedNames = 8;
inline int VerifiedNameCertificate_Details::_internal_localizednames_size() const {
  return _impl_.localizednames_.size();
}
inline int VerifiedNameCertificate_Details::localizednames_size() const {
  return _internal_localizednames_size();
}
inline void VerifiedNameCertificate_Details::clear_localizednames() {
  _impl_.localizednames_.Clear();
}
inline ::proto::LocalizedName* VerifiedNameCertificate_Details::mutable_localizednames(int index) {
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.Details.localizedNames)
  return _impl_.localizednames_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >*
VerifiedNameCertificate_Details::mutable_localizednames() {
  // @@protoc_insertion_point(field_mutable_list:proto.VerifiedNameCertificate.Details.localizedNames)
  return &_impl_.localizednames_;
}
inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::_internal_localizednames(int index) const {
  return _impl_.localizednames_.Get(index);
}
inline const ::proto::LocalizedName& VerifiedNameCertificate_Details::localizednames(int index) const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.localizedNames)
  return _internal_localizednames(index);
}
inline ::proto::LocalizedName* VerifiedNameCertificate_Details::_internal_add_localizednames() {
  return _impl_.localizednames_.Add();
}
inline ::proto::LocalizedName* VerifiedNameCertificate_Details::add_localizednames() {
  ::proto::LocalizedName* _add = _internal_add_localizednames();
  // @@protoc_insertion_point(field_add:proto.VerifiedNameCertificate.Details.localizedNames)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::LocalizedName >&
VerifiedNameCertificate_Details::localizednames() const {
  // @@protoc_insertion_point(field_list:proto.VerifiedNameCertificate.Details.localizedNames)
  return _impl_.localizednames_;
}

// optional uint64 issueTime = 10;
inline bool VerifiedNameCertificate_Details::_internal_has_issuetime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool VerifiedNameCertificate_Details::has_issuetime() const {
  return _internal_has_issuetime();
}
inline void VerifiedNameCertificate_Details::clear_issuetime() {
  _impl_.issuetime_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t VerifiedNameCertificate_Details::_internal_issuetime() const {
  return _impl_.issuetime_;
}
inline uint64_t VerifiedNameCertificate_Details::issuetime() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.Details.issueTime)
  return _internal_issuetime();
}
inline void VerifiedNameCertificate_Details::_internal_set_issuetime(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.issuetime_ = value;
}
inline void VerifiedNameCertificate_Details::set_issuetime(uint64_t value) {
  _internal_set_issuetime(value);
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.Details.issueTime)
}

// -------------------------------------------------------------------

// VerifiedNameCertificate

// optional bytes details = 1;
inline bool VerifiedNameCertificate::_internal_has_details() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool VerifiedNameCertificate::has_details() const {
  return _internal_has_details();
}
inline void VerifiedNameCertificate::clear_details() {
  _impl_.details_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& VerifiedNameCertificate::details() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.details)
  return _internal_details();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerifiedNameCertificate::set_details(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.details_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.details)
}
inline std::string* VerifiedNameCertificate::mutable_details() {
  std::string* _s = _internal_mutable_details();
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.details)
  return _s;
}
inline const std::string& VerifiedNameCertificate::_internal_details() const {
  return _impl_.details_.Get();
}
inline void VerifiedNameCertificate::_internal_set_details(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.details_.Set(value, GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::_internal_mutable_details() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.details_.Mutable(GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::release_details() {
  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.details)
  if (!_internal_has_details()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.details_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void VerifiedNameCertificate::set_allocated_details(std::string* details) {
  if (details != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.details_.SetAllocated(details, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.details_.IsDefault()) {
    _impl_.details_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.details)
}

// optional bytes signature = 2;
inline bool VerifiedNameCertificate::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool VerifiedNameCertificate::has_signature() const {
  return _internal_has_signature();
}
inline void VerifiedNameCertificate::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& VerifiedNameCertificate::signature() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerifiedNameCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.signature)
}
inline std::string* VerifiedNameCertificate::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.signature)
  return _s;
}
inline const std::string& VerifiedNameCertificate::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void VerifiedNameCertificate::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::release_signature() {
  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.signature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void VerifiedNameCertificate::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.signature)
}

// optional bytes serverSignature = 3;
inline bool VerifiedNameCertificate::_internal_has_serversignature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool VerifiedNameCertificate::has_serversignature() const {
  return _internal_has_serversignature();
}
inline void VerifiedNameCertificate::clear_serversignature() {
  _impl_.serversignature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& VerifiedNameCertificate::serversignature() const {
  // @@protoc_insertion_point(field_get:proto.VerifiedNameCertificate.serverSignature)
  return _internal_serversignature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void VerifiedNameCertificate::set_serversignature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.serversignature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.VerifiedNameCertificate.serverSignature)
}
inline std::string* VerifiedNameCertificate::mutable_serversignature() {
  std::string* _s = _internal_mutable_serversignature();
  // @@protoc_insertion_point(field_mutable:proto.VerifiedNameCertificate.serverSignature)
  return _s;
}
inline const std::string& VerifiedNameCertificate::_internal_serversignature() const {
  return _impl_.serversignature_.Get();
}
inline void VerifiedNameCertificate::_internal_set_serversignature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.serversignature_.Set(value, GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::_internal_mutable_serversignature() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.serversignature_.Mutable(GetArenaForAllocation());
}
inline std::string* VerifiedNameCertificate::release_serversignature() {
  // @@protoc_insertion_point(field_release:proto.VerifiedNameCertificate.serverSignature)
  if (!_internal_has_serversignature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.serversignature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serversignature_.IsDefault()) {
    _impl_.serversignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void VerifiedNameCertificate::set_allocated_serversignature(std::string* serversignature) {
  if (serversignature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.serversignature_.SetAllocated(serversignature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.serversignature_.IsDefault()) {
    _impl_.serversignature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.VerifiedNameCertificate.serverSignature)
}

// -------------------------------------------------------------------

// WallpaperSettings

// optional string filename = 1;
inline bool WallpaperSettings::_internal_has_filename() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WallpaperSettings::has_filename() const {
  return _internal_has_filename();
}
inline void WallpaperSettings::clear_filename() {
  _impl_.filename_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& WallpaperSettings::filename() const {
  // @@protoc_insertion_point(field_get:proto.WallpaperSettings.filename)
  return _internal_filename();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WallpaperSettings::set_filename(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.filename_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WallpaperSettings.filename)
}
inline std::string* WallpaperSettings::mutable_filename() {
  std::string* _s = _internal_mutable_filename();
  // @@protoc_insertion_point(field_mutable:proto.WallpaperSettings.filename)
  return _s;
}
inline const std::string& WallpaperSettings::_internal_filename() const {
  return _impl_.filename_.Get();
}
inline void WallpaperSettings::_internal_set_filename(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.filename_.Set(value, GetArenaForAllocation());
}
inline std::string* WallpaperSettings::_internal_mutable_filename() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.filename_.Mutable(GetArenaForAllocation());
}
inline std::string* WallpaperSettings::release_filename() {
  // @@protoc_insertion_point(field_release:proto.WallpaperSettings.filename)
  if (!_internal_has_filename()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  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 WallpaperSettings::set_allocated_filename(std::string* filename) {
  if (filename != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _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:proto.WallpaperSettings.filename)
}

// optional uint32 opacity = 2;
inline bool WallpaperSettings::_internal_has_opacity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WallpaperSettings::has_opacity() const {
  return _internal_has_opacity();
}
inline void WallpaperSettings::clear_opacity() {
  _impl_.opacity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t WallpaperSettings::_internal_opacity() const {
  return _impl_.opacity_;
}
inline uint32_t WallpaperSettings::opacity() const {
  // @@protoc_insertion_point(field_get:proto.WallpaperSettings.opacity)
  return _internal_opacity();
}
inline void WallpaperSettings::_internal_set_opacity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.opacity_ = value;
}
inline void WallpaperSettings::set_opacity(uint32_t value) {
  _internal_set_opacity(value);
  // @@protoc_insertion_point(field_set:proto.WallpaperSettings.opacity)
}

// -------------------------------------------------------------------

// WebFeatures

// optional .proto.WebFeatures.Flag labelsDisplay = 1;
inline bool WebFeatures::_internal_has_labelsdisplay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WebFeatures::has_labelsdisplay() const {
  return _internal_has_labelsdisplay();
}
inline void WebFeatures::clear_labelsdisplay() {
  _impl_.labelsdisplay_ = 0;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsdisplay() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsdisplay_);
}
inline ::proto::WebFeatures_Flag WebFeatures::labelsdisplay() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsDisplay)
  return _internal_labelsdisplay();
}
inline void WebFeatures::_internal_set_labelsdisplay(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.labelsdisplay_ = value;
}
inline void WebFeatures::set_labelsdisplay(::proto::WebFeatures_Flag value) {
  _internal_set_labelsdisplay(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsDisplay)
}

// optional .proto.WebFeatures.Flag voipIndividualOutgoing = 2;
inline bool WebFeatures::_internal_has_voipindividualoutgoing() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WebFeatures::has_voipindividualoutgoing() const {
  return _internal_has_voipindividualoutgoing();
}
inline void WebFeatures::clear_voipindividualoutgoing() {
  _impl_.voipindividualoutgoing_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualoutgoing() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualoutgoing_);
}
inline ::proto::WebFeatures_Flag WebFeatures::voipindividualoutgoing() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualOutgoing)
  return _internal_voipindividualoutgoing();
}
inline void WebFeatures::_internal_set_voipindividualoutgoing(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.voipindividualoutgoing_ = value;
}
inline void WebFeatures::set_voipindividualoutgoing(::proto::WebFeatures_Flag value) {
  _internal_set_voipindividualoutgoing(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualOutgoing)
}

// optional .proto.WebFeatures.Flag groupsV3 = 3;
inline bool WebFeatures::_internal_has_groupsv3() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool WebFeatures::has_groupsv3() const {
  return _internal_has_groupsv3();
}
inline void WebFeatures::clear_groupsv3() {
  _impl_.groupsv3_ = 0;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3_);
}
inline ::proto::WebFeatures_Flag WebFeatures::groupsv3() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3)
  return _internal_groupsv3();
}
inline void WebFeatures::_internal_set_groupsv3(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.groupsv3_ = value;
}
inline void WebFeatures::set_groupsv3(::proto::WebFeatures_Flag value) {
  _internal_set_groupsv3(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3)
}

// optional .proto.WebFeatures.Flag groupsV3Create = 4;
inline bool WebFeatures::_internal_has_groupsv3create() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool WebFeatures::has_groupsv3create() const {
  return _internal_has_groupsv3create();
}
inline void WebFeatures::clear_groupsv3create() {
  _impl_.groupsv3create_ = 0;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv3create() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv3create_);
}
inline ::proto::WebFeatures_Flag WebFeatures::groupsv3create() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV3Create)
  return _internal_groupsv3create();
}
inline void WebFeatures::_internal_set_groupsv3create(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.groupsv3create_ = value;
}
inline void WebFeatures::set_groupsv3create(::proto::WebFeatures_Flag value) {
  _internal_set_groupsv3create(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV3Create)
}

// optional .proto.WebFeatures.Flag changeNumberV2 = 5;
inline bool WebFeatures::_internal_has_changenumberv2() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool WebFeatures::has_changenumberv2() const {
  return _internal_has_changenumberv2();
}
inline void WebFeatures::clear_changenumberv2() {
  _impl_.changenumberv2_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_changenumberv2() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.changenumberv2_);
}
inline ::proto::WebFeatures_Flag WebFeatures::changenumberv2() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.changeNumberV2)
  return _internal_changenumberv2();
}
inline void WebFeatures::_internal_set_changenumberv2(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.changenumberv2_ = value;
}
inline void WebFeatures::set_changenumberv2(::proto::WebFeatures_Flag value) {
  _internal_set_changenumberv2(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.changeNumberV2)
}

// optional .proto.WebFeatures.Flag queryStatusV3Thumbnail = 6;
inline bool WebFeatures::_internal_has_querystatusv3thumbnail() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool WebFeatures::has_querystatusv3thumbnail() const {
  return _internal_has_querystatusv3thumbnail();
}
inline void WebFeatures::clear_querystatusv3thumbnail() {
  _impl_.querystatusv3thumbnail_ = 0;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_querystatusv3thumbnail() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.querystatusv3thumbnail_);
}
inline ::proto::WebFeatures_Flag WebFeatures::querystatusv3thumbnail() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.queryStatusV3Thumbnail)
  return _internal_querystatusv3thumbnail();
}
inline void WebFeatures::_internal_set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.querystatusv3thumbnail_ = value;
}
inline void WebFeatures::set_querystatusv3thumbnail(::proto::WebFeatures_Flag value) {
  _internal_set_querystatusv3thumbnail(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.queryStatusV3Thumbnail)
}

// optional .proto.WebFeatures.Flag liveLocations = 7;
inline bool WebFeatures::_internal_has_livelocations() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool WebFeatures::has_livelocations() const {
  return _internal_has_livelocations();
}
inline void WebFeatures::clear_livelocations() {
  _impl_.livelocations_ = 0;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocations() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocations_);
}
inline ::proto::WebFeatures_Flag WebFeatures::livelocations() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocations)
  return _internal_livelocations();
}
inline void WebFeatures::_internal_set_livelocations(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.livelocations_ = value;
}
inline void WebFeatures::set_livelocations(::proto::WebFeatures_Flag value) {
  _internal_set_livelocations(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocations)
}

// optional .proto.WebFeatures.Flag queryVname = 8;
inline bool WebFeatures::_internal_has_queryvname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool WebFeatures::has_queryvname() const {
  return _internal_has_queryvname();
}
inline void WebFeatures::clear_queryvname() {
  _impl_.queryvname_ = 0;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_queryvname() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.queryvname_);
}
inline ::proto::WebFeatures_Flag WebFeatures::queryvname() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.queryVname)
  return _internal_queryvname();
}
inline void WebFeatures::_internal_set_queryvname(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.queryvname_ = value;
}
inline void WebFeatures::set_queryvname(::proto::WebFeatures_Flag value) {
  _internal_set_queryvname(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.queryVname)
}

// optional .proto.WebFeatures.Flag voipIndividualIncoming = 9;
inline bool WebFeatures::_internal_has_voipindividualincoming() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool WebFeatures::has_voipindividualincoming() const {
  return _internal_has_voipindividualincoming();
}
inline void WebFeatures::clear_voipindividualincoming() {
  _impl_.voipindividualincoming_ = 0;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualincoming() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualincoming_);
}
inline ::proto::WebFeatures_Flag WebFeatures::voipindividualincoming() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualIncoming)
  return _internal_voipindividualincoming();
}
inline void WebFeatures::_internal_set_voipindividualincoming(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.voipindividualincoming_ = value;
}
inline void WebFeatures::set_voipindividualincoming(::proto::WebFeatures_Flag value) {
  _internal_set_voipindividualincoming(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualIncoming)
}

// optional .proto.WebFeatures.Flag quickRepliesQuery = 10;
inline bool WebFeatures::_internal_has_quickrepliesquery() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool WebFeatures::has_quickrepliesquery() const {
  return _internal_has_quickrepliesquery();
}
inline void WebFeatures::clear_quickrepliesquery() {
  _impl_.quickrepliesquery_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_quickrepliesquery() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.quickrepliesquery_);
}
inline ::proto::WebFeatures_Flag WebFeatures::quickrepliesquery() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.quickRepliesQuery)
  return _internal_quickrepliesquery();
}
inline void WebFeatures::_internal_set_quickrepliesquery(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.quickrepliesquery_ = value;
}
inline void WebFeatures::set_quickrepliesquery(::proto::WebFeatures_Flag value) {
  _internal_set_quickrepliesquery(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.quickRepliesQuery)
}

// optional .proto.WebFeatures.Flag payments = 11;
inline bool WebFeatures::_internal_has_payments() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool WebFeatures::has_payments() const {
  return _internal_has_payments();
}
inline void WebFeatures::clear_payments() {
  _impl_.payments_ = 0;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_payments() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.payments_);
}
inline ::proto::WebFeatures_Flag WebFeatures::payments() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.payments)
  return _internal_payments();
}
inline void WebFeatures::_internal_set_payments(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.payments_ = value;
}
inline void WebFeatures::set_payments(::proto::WebFeatures_Flag value) {
  _internal_set_payments(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.payments)
}

// optional .proto.WebFeatures.Flag stickerPackQuery = 12;
inline bool WebFeatures::_internal_has_stickerpackquery() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool WebFeatures::has_stickerpackquery() const {
  return _internal_has_stickerpackquery();
}
inline void WebFeatures::clear_stickerpackquery() {
  _impl_.stickerpackquery_ = 0;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_stickerpackquery() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.stickerpackquery_);
}
inline ::proto::WebFeatures_Flag WebFeatures::stickerpackquery() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.stickerPackQuery)
  return _internal_stickerpackquery();
}
inline void WebFeatures::_internal_set_stickerpackquery(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.stickerpackquery_ = value;
}
inline void WebFeatures::set_stickerpackquery(::proto::WebFeatures_Flag value) {
  _internal_set_stickerpackquery(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.stickerPackQuery)
}

// optional .proto.WebFeatures.Flag liveLocationsFinal = 13;
inline bool WebFeatures::_internal_has_livelocationsfinal() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool WebFeatures::has_livelocationsfinal() const {
  return _internal_has_livelocationsfinal();
}
inline void WebFeatures::clear_livelocationsfinal() {
  _impl_.livelocationsfinal_ = 0;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_livelocationsfinal() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.livelocationsfinal_);
}
inline ::proto::WebFeatures_Flag WebFeatures::livelocationsfinal() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.liveLocationsFinal)
  return _internal_livelocationsfinal();
}
inline void WebFeatures::_internal_set_livelocationsfinal(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.livelocationsfinal_ = value;
}
inline void WebFeatures::set_livelocationsfinal(::proto::WebFeatures_Flag value) {
  _internal_set_livelocationsfinal(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.liveLocationsFinal)
}

// optional .proto.WebFeatures.Flag labelsEdit = 14;
inline bool WebFeatures::_internal_has_labelsedit() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool WebFeatures::has_labelsedit() const {
  return _internal_has_labelsedit();
}
inline void WebFeatures::clear_labelsedit() {
  _impl_.labelsedit_ = 0;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_labelsedit() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.labelsedit_);
}
inline ::proto::WebFeatures_Flag WebFeatures::labelsedit() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.labelsEdit)
  return _internal_labelsedit();
}
inline void WebFeatures::_internal_set_labelsedit(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.labelsedit_ = value;
}
inline void WebFeatures::set_labelsedit(::proto::WebFeatures_Flag value) {
  _internal_set_labelsedit(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.labelsEdit)
}

// optional .proto.WebFeatures.Flag mediaUpload = 15;
inline bool WebFeatures::_internal_has_mediaupload() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool WebFeatures::has_mediaupload() const {
  return _internal_has_mediaupload();
}
inline void WebFeatures::clear_mediaupload() {
  _impl_.mediaupload_ = 0;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediaupload() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediaupload_);
}
inline ::proto::WebFeatures_Flag WebFeatures::mediaupload() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUpload)
  return _internal_mediaupload();
}
inline void WebFeatures::_internal_set_mediaupload(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.mediaupload_ = value;
}
inline void WebFeatures::set_mediaupload(::proto::WebFeatures_Flag value) {
  _internal_set_mediaupload(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUpload)
}

// optional .proto.WebFeatures.Flag mediaUploadRichQuickReplies = 18;
inline bool WebFeatures::_internal_has_mediauploadrichquickreplies() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool WebFeatures::has_mediauploadrichquickreplies() const {
  return _internal_has_mediauploadrichquickreplies();
}
inline void WebFeatures::clear_mediauploadrichquickreplies() {
  _impl_.mediauploadrichquickreplies_ = 0;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_mediauploadrichquickreplies() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mediauploadrichquickreplies_);
}
inline ::proto::WebFeatures_Flag WebFeatures::mediauploadrichquickreplies() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.mediaUploadRichQuickReplies)
  return _internal_mediauploadrichquickreplies();
}
inline void WebFeatures::_internal_set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.mediauploadrichquickreplies_ = value;
}
inline void WebFeatures::set_mediauploadrichquickreplies(::proto::WebFeatures_Flag value) {
  _internal_set_mediauploadrichquickreplies(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.mediaUploadRichQuickReplies)
}

// optional .proto.WebFeatures.Flag vnameV2 = 19;
inline bool WebFeatures::_internal_has_vnamev2() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool WebFeatures::has_vnamev2() const {
  return _internal_has_vnamev2();
}
inline void WebFeatures::clear_vnamev2() {
  _impl_.vnamev2_ = 0;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_vnamev2() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.vnamev2_);
}
inline ::proto::WebFeatures_Flag WebFeatures::vnamev2() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.vnameV2)
  return _internal_vnamev2();
}
inline void WebFeatures::_internal_set_vnamev2(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.vnamev2_ = value;
}
inline void WebFeatures::set_vnamev2(::proto::WebFeatures_Flag value) {
  _internal_set_vnamev2(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.vnameV2)
}

// optional .proto.WebFeatures.Flag videoPlaybackUrl = 20;
inline bool WebFeatures::_internal_has_videoplaybackurl() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool WebFeatures::has_videoplaybackurl() const {
  return _internal_has_videoplaybackurl();
}
inline void WebFeatures::clear_videoplaybackurl() {
  _impl_.videoplaybackurl_ = 0;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_videoplaybackurl() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.videoplaybackurl_);
}
inline ::proto::WebFeatures_Flag WebFeatures::videoplaybackurl() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.videoPlaybackUrl)
  return _internal_videoplaybackurl();
}
inline void WebFeatures::_internal_set_videoplaybackurl(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.videoplaybackurl_ = value;
}
inline void WebFeatures::set_videoplaybackurl(::proto::WebFeatures_Flag value) {
  _internal_set_videoplaybackurl(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.videoPlaybackUrl)
}

// optional .proto.WebFeatures.Flag statusRanking = 21;
inline bool WebFeatures::_internal_has_statusranking() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool WebFeatures::has_statusranking() const {
  return _internal_has_statusranking();
}
inline void WebFeatures::clear_statusranking() {
  _impl_.statusranking_ = 0;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_statusranking() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.statusranking_);
}
inline ::proto::WebFeatures_Flag WebFeatures::statusranking() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.statusRanking)
  return _internal_statusranking();
}
inline void WebFeatures::_internal_set_statusranking(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.statusranking_ = value;
}
inline void WebFeatures::set_statusranking(::proto::WebFeatures_Flag value) {
  _internal_set_statusranking(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.statusRanking)
}

// optional .proto.WebFeatures.Flag voipIndividualVideo = 22;
inline bool WebFeatures::_internal_has_voipindividualvideo() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool WebFeatures::has_voipindividualvideo() const {
  return _internal_has_voipindividualvideo();
}
inline void WebFeatures::clear_voipindividualvideo() {
  _impl_.voipindividualvideo_ = 0;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipindividualvideo() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipindividualvideo_);
}
inline ::proto::WebFeatures_Flag WebFeatures::voipindividualvideo() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipIndividualVideo)
  return _internal_voipindividualvideo();
}
inline void WebFeatures::_internal_set_voipindividualvideo(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.voipindividualvideo_ = value;
}
inline void WebFeatures::set_voipindividualvideo(::proto::WebFeatures_Flag value) {
  _internal_set_voipindividualvideo(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipIndividualVideo)
}

// optional .proto.WebFeatures.Flag thirdPartyStickers = 23;
inline bool WebFeatures::_internal_has_thirdpartystickers() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool WebFeatures::has_thirdpartystickers() const {
  return _internal_has_thirdpartystickers();
}
inline void WebFeatures::clear_thirdpartystickers() {
  _impl_.thirdpartystickers_ = 0;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_thirdpartystickers() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.thirdpartystickers_);
}
inline ::proto::WebFeatures_Flag WebFeatures::thirdpartystickers() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.thirdPartyStickers)
  return _internal_thirdpartystickers();
}
inline void WebFeatures::_internal_set_thirdpartystickers(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.thirdpartystickers_ = value;
}
inline void WebFeatures::set_thirdpartystickers(::proto::WebFeatures_Flag value) {
  _internal_set_thirdpartystickers(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.thirdPartyStickers)
}

// optional .proto.WebFeatures.Flag frequentlyForwardedSetting = 24;
inline bool WebFeatures::_internal_has_frequentlyforwardedsetting() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool WebFeatures::has_frequentlyforwardedsetting() const {
  return _internal_has_frequentlyforwardedsetting();
}
inline void WebFeatures::clear_frequentlyforwardedsetting() {
  _impl_.frequentlyforwardedsetting_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_frequentlyforwardedsetting() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.frequentlyforwardedsetting_);
}
inline ::proto::WebFeatures_Flag WebFeatures::frequentlyforwardedsetting() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.frequentlyForwardedSetting)
  return _internal_frequentlyforwardedsetting();
}
inline void WebFeatures::_internal_set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.frequentlyforwardedsetting_ = value;
}
inline void WebFeatures::set_frequentlyforwardedsetting(::proto::WebFeatures_Flag value) {
  _internal_set_frequentlyforwardedsetting(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.frequentlyForwardedSetting)
}

// optional .proto.WebFeatures.Flag groupsV4JoinPermission = 25;
inline bool WebFeatures::_internal_has_groupsv4joinpermission() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool WebFeatures::has_groupsv4joinpermission() const {
  return _internal_has_groupsv4joinpermission();
}
inline void WebFeatures::clear_groupsv4joinpermission() {
  _impl_.groupsv4joinpermission_ = 0;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupsv4joinpermission() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupsv4joinpermission_);
}
inline ::proto::WebFeatures_Flag WebFeatures::groupsv4joinpermission() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupsV4JoinPermission)
  return _internal_groupsv4joinpermission();
}
inline void WebFeatures::_internal_set_groupsv4joinpermission(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.groupsv4joinpermission_ = value;
}
inline void WebFeatures::set_groupsv4joinpermission(::proto::WebFeatures_Flag value) {
  _internal_set_groupsv4joinpermission(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupsV4JoinPermission)
}

// optional .proto.WebFeatures.Flag recentStickers = 26;
inline bool WebFeatures::_internal_has_recentstickers() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool WebFeatures::has_recentstickers() const {
  return _internal_has_recentstickers();
}
inline void WebFeatures::clear_recentstickers() {
  _impl_.recentstickers_ = 0;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickers() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickers_);
}
inline ::proto::WebFeatures_Flag WebFeatures::recentstickers() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickers)
  return _internal_recentstickers();
}
inline void WebFeatures::_internal_set_recentstickers(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.recentstickers_ = value;
}
inline void WebFeatures::set_recentstickers(::proto::WebFeatures_Flag value) {
  _internal_set_recentstickers(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickers)
}

// optional .proto.WebFeatures.Flag catalog = 27;
inline bool WebFeatures::_internal_has_catalog() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool WebFeatures::has_catalog() const {
  return _internal_has_catalog();
}
inline void WebFeatures::clear_catalog() {
  _impl_.catalog_ = 0;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_catalog() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.catalog_);
}
inline ::proto::WebFeatures_Flag WebFeatures::catalog() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.catalog)
  return _internal_catalog();
}
inline void WebFeatures::_internal_set_catalog(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.catalog_ = value;
}
inline void WebFeatures::set_catalog(::proto::WebFeatures_Flag value) {
  _internal_set_catalog(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.catalog)
}

// optional .proto.WebFeatures.Flag starredStickers = 28;
inline bool WebFeatures::_internal_has_starredstickers() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool WebFeatures::has_starredstickers() const {
  return _internal_has_starredstickers();
}
inline void WebFeatures::clear_starredstickers() {
  _impl_.starredstickers_ = 0;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_starredstickers() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.starredstickers_);
}
inline ::proto::WebFeatures_Flag WebFeatures::starredstickers() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.starredStickers)
  return _internal_starredstickers();
}
inline void WebFeatures::_internal_set_starredstickers(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.starredstickers_ = value;
}
inline void WebFeatures::set_starredstickers(::proto::WebFeatures_Flag value) {
  _internal_set_starredstickers(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.starredStickers)
}

// optional .proto.WebFeatures.Flag voipGroupCall = 29;
inline bool WebFeatures::_internal_has_voipgroupcall() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool WebFeatures::has_voipgroupcall() const {
  return _internal_has_voipgroupcall();
}
inline void WebFeatures::clear_voipgroupcall() {
  _impl_.voipgroupcall_ = 0;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_voipgroupcall() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.voipgroupcall_);
}
inline ::proto::WebFeatures_Flag WebFeatures::voipgroupcall() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.voipGroupCall)
  return _internal_voipgroupcall();
}
inline void WebFeatures::_internal_set_voipgroupcall(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.voipgroupcall_ = value;
}
inline void WebFeatures::set_voipgroupcall(::proto::WebFeatures_Flag value) {
  _internal_set_voipgroupcall(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.voipGroupCall)
}

// optional .proto.WebFeatures.Flag templateMessage = 30;
inline bool WebFeatures::_internal_has_templatemessage() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool WebFeatures::has_templatemessage() const {
  return _internal_has_templatemessage();
}
inline void WebFeatures::clear_templatemessage() {
  _impl_.templatemessage_ = 0;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessage() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessage_);
}
inline ::proto::WebFeatures_Flag WebFeatures::templatemessage() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessage)
  return _internal_templatemessage();
}
inline void WebFeatures::_internal_set_templatemessage(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.templatemessage_ = value;
}
inline void WebFeatures::set_templatemessage(::proto::WebFeatures_Flag value) {
  _internal_set_templatemessage(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessage)
}

// optional .proto.WebFeatures.Flag templateMessageInteractivity = 31;
inline bool WebFeatures::_internal_has_templatemessageinteractivity() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool WebFeatures::has_templatemessageinteractivity() const {
  return _internal_has_templatemessageinteractivity();
}
inline void WebFeatures::clear_templatemessageinteractivity() {
  _impl_.templatemessageinteractivity_ = 0;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_templatemessageinteractivity() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.templatemessageinteractivity_);
}
inline ::proto::WebFeatures_Flag WebFeatures::templatemessageinteractivity() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.templateMessageInteractivity)
  return _internal_templatemessageinteractivity();
}
inline void WebFeatures::_internal_set_templatemessageinteractivity(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.templatemessageinteractivity_ = value;
}
inline void WebFeatures::set_templatemessageinteractivity(::proto::WebFeatures_Flag value) {
  _internal_set_templatemessageinteractivity(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.templateMessageInteractivity)
}

// optional .proto.WebFeatures.Flag ephemeralMessages = 32;
inline bool WebFeatures::_internal_has_ephemeralmessages() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool WebFeatures::has_ephemeralmessages() const {
  return _internal_has_ephemeralmessages();
}
inline void WebFeatures::clear_ephemeralmessages() {
  _impl_.ephemeralmessages_ = 0;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralmessages() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralmessages_);
}
inline ::proto::WebFeatures_Flag WebFeatures::ephemeralmessages() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralMessages)
  return _internal_ephemeralmessages();
}
inline void WebFeatures::_internal_set_ephemeralmessages(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.ephemeralmessages_ = value;
}
inline void WebFeatures::set_ephemeralmessages(::proto::WebFeatures_Flag value) {
  _internal_set_ephemeralmessages(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralMessages)
}

// optional .proto.WebFeatures.Flag e2ENotificationSync = 33;
inline bool WebFeatures::_internal_has_e2enotificationsync() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool WebFeatures::has_e2enotificationsync() const {
  return _internal_has_e2enotificationsync();
}
inline void WebFeatures::clear_e2enotificationsync() {
  _impl_.e2enotificationsync_ = 0;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_e2enotificationsync() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.e2enotificationsync_);
}
inline ::proto::WebFeatures_Flag WebFeatures::e2enotificationsync() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.e2ENotificationSync)
  return _internal_e2enotificationsync();
}
inline void WebFeatures::_internal_set_e2enotificationsync(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.e2enotificationsync_ = value;
}
inline void WebFeatures::set_e2enotificationsync(::proto::WebFeatures_Flag value) {
  _internal_set_e2enotificationsync(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.e2ENotificationSync)
}

// optional .proto.WebFeatures.Flag recentStickersV2 = 34;
inline bool WebFeatures::_internal_has_recentstickersv2() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool WebFeatures::has_recentstickersv2() const {
  return _internal_has_recentstickersv2();
}
inline void WebFeatures::clear_recentstickersv2() {
  _impl_.recentstickersv2_ = 0;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv2() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv2_);
}
inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv2() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV2)
  return _internal_recentstickersv2();
}
inline void WebFeatures::_internal_set_recentstickersv2(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.recentstickersv2_ = value;
}
inline void WebFeatures::set_recentstickersv2(::proto::WebFeatures_Flag value) {
  _internal_set_recentstickersv2(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV2)
}

// optional .proto.WebFeatures.Flag recentStickersV3 = 36;
inline bool WebFeatures::_internal_has_recentstickersv3() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool WebFeatures::has_recentstickersv3() const {
  return _internal_has_recentstickersv3();
}
inline void WebFeatures::clear_recentstickersv3() {
  _impl_.recentstickersv3_ = 0;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_recentstickersv3() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.recentstickersv3_);
}
inline ::proto::WebFeatures_Flag WebFeatures::recentstickersv3() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.recentStickersV3)
  return _internal_recentstickersv3();
}
inline void WebFeatures::_internal_set_recentstickersv3(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.recentstickersv3_ = value;
}
inline void WebFeatures::set_recentstickersv3(::proto::WebFeatures_Flag value) {
  _internal_set_recentstickersv3(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.recentStickersV3)
}

// optional .proto.WebFeatures.Flag userNotice = 37;
inline bool WebFeatures::_internal_has_usernotice() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool WebFeatures::has_usernotice() const {
  return _internal_has_usernotice();
}
inline void WebFeatures::clear_usernotice() {
  _impl_.usernotice_ = 0;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_usernotice() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.usernotice_);
}
inline ::proto::WebFeatures_Flag WebFeatures::usernotice() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.userNotice)
  return _internal_usernotice();
}
inline void WebFeatures::_internal_set_usernotice(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.usernotice_ = value;
}
inline void WebFeatures::set_usernotice(::proto::WebFeatures_Flag value) {
  _internal_set_usernotice(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.userNotice)
}

// optional .proto.WebFeatures.Flag support = 39;
inline bool WebFeatures::_internal_has_support() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool WebFeatures::has_support() const {
  return _internal_has_support();
}
inline void WebFeatures::clear_support() {
  _impl_.support_ = 0;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_support() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.support_);
}
inline ::proto::WebFeatures_Flag WebFeatures::support() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.support)
  return _internal_support();
}
inline void WebFeatures::_internal_set_support(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.support_ = value;
}
inline void WebFeatures::set_support(::proto::WebFeatures_Flag value) {
  _internal_set_support(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.support)
}

// optional .proto.WebFeatures.Flag groupUiiCleanup = 40;
inline bool WebFeatures::_internal_has_groupuiicleanup() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool WebFeatures::has_groupuiicleanup() const {
  return _internal_has_groupuiicleanup();
}
inline void WebFeatures::clear_groupuiicleanup() {
  _impl_.groupuiicleanup_ = 0;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupuiicleanup() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupuiicleanup_);
}
inline ::proto::WebFeatures_Flag WebFeatures::groupuiicleanup() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupUiiCleanup)
  return _internal_groupuiicleanup();
}
inline void WebFeatures::_internal_set_groupuiicleanup(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000008u;
  _impl_.groupuiicleanup_ = value;
}
inline void WebFeatures::set_groupuiicleanup(::proto::WebFeatures_Flag value) {
  _internal_set_groupuiicleanup(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupUiiCleanup)
}

// optional .proto.WebFeatures.Flag groupDogfoodingInternalOnly = 41;
inline bool WebFeatures::_internal_has_groupdogfoodinginternalonly() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool WebFeatures::has_groupdogfoodinginternalonly() const {
  return _internal_has_groupdogfoodinginternalonly();
}
inline void WebFeatures::clear_groupdogfoodinginternalonly() {
  _impl_.groupdogfoodinginternalonly_ = 0;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_groupdogfoodinginternalonly() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.groupdogfoodinginternalonly_);
}
inline ::proto::WebFeatures_Flag WebFeatures::groupdogfoodinginternalonly() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.groupDogfoodingInternalOnly)
  return _internal_groupdogfoodinginternalonly();
}
inline void WebFeatures::_internal_set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000010u;
  _impl_.groupdogfoodinginternalonly_ = value;
}
inline void WebFeatures::set_groupdogfoodinginternalonly(::proto::WebFeatures_Flag value) {
  _internal_set_groupdogfoodinginternalonly(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.groupDogfoodingInternalOnly)
}

// optional .proto.WebFeatures.Flag settingsSync = 42;
inline bool WebFeatures::_internal_has_settingssync() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool WebFeatures::has_settingssync() const {
  return _internal_has_settingssync();
}
inline void WebFeatures::clear_settingssync() {
  _impl_.settingssync_ = 0;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_settingssync() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.settingssync_);
}
inline ::proto::WebFeatures_Flag WebFeatures::settingssync() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.settingsSync)
  return _internal_settingssync();
}
inline void WebFeatures::_internal_set_settingssync(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000020u;
  _impl_.settingssync_ = value;
}
inline void WebFeatures::set_settingssync(::proto::WebFeatures_Flag value) {
  _internal_set_settingssync(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.settingsSync)
}

// optional .proto.WebFeatures.Flag archiveV2 = 43;
inline bool WebFeatures::_internal_has_archivev2() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline bool WebFeatures::has_archivev2() const {
  return _internal_has_archivev2();
}
inline void WebFeatures::clear_archivev2() {
  _impl_.archivev2_ = 0;
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_archivev2() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.archivev2_);
}
inline ::proto::WebFeatures_Flag WebFeatures::archivev2() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.archiveV2)
  return _internal_archivev2();
}
inline void WebFeatures::_internal_set_archivev2(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000040u;
  _impl_.archivev2_ = value;
}
inline void WebFeatures::set_archivev2(::proto::WebFeatures_Flag value) {
  _internal_set_archivev2(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.archiveV2)
}

// optional .proto.WebFeatures.Flag ephemeralAllowGroupMembers = 44;
inline bool WebFeatures::_internal_has_ephemeralallowgroupmembers() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool WebFeatures::has_ephemeralallowgroupmembers() const {
  return _internal_has_ephemeralallowgroupmembers();
}
inline void WebFeatures::clear_ephemeralallowgroupmembers() {
  _impl_.ephemeralallowgroupmembers_ = 0;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeralallowgroupmembers() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeralallowgroupmembers_);
}
inline ::proto::WebFeatures_Flag WebFeatures::ephemeralallowgroupmembers() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeralAllowGroupMembers)
  return _internal_ephemeralallowgroupmembers();
}
inline void WebFeatures::_internal_set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000080u;
  _impl_.ephemeralallowgroupmembers_ = value;
}
inline void WebFeatures::set_ephemeralallowgroupmembers(::proto::WebFeatures_Flag value) {
  _internal_set_ephemeralallowgroupmembers(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeralAllowGroupMembers)
}

// optional .proto.WebFeatures.Flag ephemeral24HDuration = 45;
inline bool WebFeatures::_internal_has_ephemeral24hduration() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool WebFeatures::has_ephemeral24hduration() const {
  return _internal_has_ephemeral24hduration();
}
inline void WebFeatures::clear_ephemeral24hduration() {
  _impl_.ephemeral24hduration_ = 0;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_ephemeral24hduration() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.ephemeral24hduration_);
}
inline ::proto::WebFeatures_Flag WebFeatures::ephemeral24hduration() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.ephemeral24HDuration)
  return _internal_ephemeral24hduration();
}
inline void WebFeatures::_internal_set_ephemeral24hduration(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000100u;
  _impl_.ephemeral24hduration_ = value;
}
inline void WebFeatures::set_ephemeral24hduration(::proto::WebFeatures_Flag value) {
  _internal_set_ephemeral24hduration(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.ephemeral24HDuration)
}

// optional .proto.WebFeatures.Flag mdForceUpgrade = 46;
inline bool WebFeatures::_internal_has_mdforceupgrade() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline bool WebFeatures::has_mdforceupgrade() const {
  return _internal_has_mdforceupgrade();
}
inline void WebFeatures::clear_mdforceupgrade() {
  _impl_.mdforceupgrade_ = 0;
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_mdforceupgrade() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.mdforceupgrade_);
}
inline ::proto::WebFeatures_Flag WebFeatures::mdforceupgrade() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.mdForceUpgrade)
  return _internal_mdforceupgrade();
}
inline void WebFeatures::_internal_set_mdforceupgrade(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000200u;
  _impl_.mdforceupgrade_ = value;
}
inline void WebFeatures::set_mdforceupgrade(::proto::WebFeatures_Flag value) {
  _internal_set_mdforceupgrade(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.mdForceUpgrade)
}

// optional .proto.WebFeatures.Flag disappearingMode = 47;
inline bool WebFeatures::_internal_has_disappearingmode() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool WebFeatures::has_disappearingmode() const {
  return _internal_has_disappearingmode();
}
inline void WebFeatures::clear_disappearingmode() {
  _impl_.disappearingmode_ = 0;
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_disappearingmode() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.disappearingmode_);
}
inline ::proto::WebFeatures_Flag WebFeatures::disappearingmode() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.disappearingMode)
  return _internal_disappearingmode();
}
inline void WebFeatures::_internal_set_disappearingmode(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000400u;
  _impl_.disappearingmode_ = value;
}
inline void WebFeatures::set_disappearingmode(::proto::WebFeatures_Flag value) {
  _internal_set_disappearingmode(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.disappearingMode)
}

// optional .proto.WebFeatures.Flag externalMdOptInAvailable = 48;
inline bool WebFeatures::_internal_has_externalmdoptinavailable() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline bool WebFeatures::has_externalmdoptinavailable() const {
  return _internal_has_externalmdoptinavailable();
}
inline void WebFeatures::clear_externalmdoptinavailable() {
  _impl_.externalmdoptinavailable_ = 0;
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_externalmdoptinavailable() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.externalmdoptinavailable_);
}
inline ::proto::WebFeatures_Flag WebFeatures::externalmdoptinavailable() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.externalMdOptInAvailable)
  return _internal_externalmdoptinavailable();
}
inline void WebFeatures::_internal_set_externalmdoptinavailable(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000800u;
  _impl_.externalmdoptinavailable_ = value;
}
inline void WebFeatures::set_externalmdoptinavailable(::proto::WebFeatures_Flag value) {
  _internal_set_externalmdoptinavailable(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.externalMdOptInAvailable)
}

// optional .proto.WebFeatures.Flag noDeleteMessageTimeLimit = 49;
inline bool WebFeatures::_internal_has_nodeletemessagetimelimit() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline bool WebFeatures::has_nodeletemessagetimelimit() const {
  return _internal_has_nodeletemessagetimelimit();
}
inline void WebFeatures::clear_nodeletemessagetimelimit() {
  _impl_.nodeletemessagetimelimit_ = 0;
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline ::proto::WebFeatures_Flag WebFeatures::_internal_nodeletemessagetimelimit() const {
  return static_cast< ::proto::WebFeatures_Flag >(_impl_.nodeletemessagetimelimit_);
}
inline ::proto::WebFeatures_Flag WebFeatures::nodeletemessagetimelimit() const {
  // @@protoc_insertion_point(field_get:proto.WebFeatures.noDeleteMessageTimeLimit)
  return _internal_nodeletemessagetimelimit();
}
inline void WebFeatures::_internal_set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) {
  assert(::proto::WebFeatures_Flag_IsValid(value));
  _impl_._has_bits_[1] |= 0x00001000u;
  _impl_.nodeletemessagetimelimit_ = value;
}
inline void WebFeatures::set_nodeletemessagetimelimit(::proto::WebFeatures_Flag value) {
  _internal_set_nodeletemessagetimelimit(value);
  // @@protoc_insertion_point(field_set:proto.WebFeatures.noDeleteMessageTimeLimit)
}

// -------------------------------------------------------------------

// WebMessageInfo

// required .proto.MessageKey key = 1;
inline bool WebMessageInfo::_internal_has_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.key_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_key() const {
  return _internal_has_key();
}
inline void WebMessageInfo::clear_key() {
  if (_impl_.key_ != nullptr) _impl_.key_->Clear();
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline const ::proto::MessageKey& WebMessageInfo::_internal_key() const {
  const ::proto::MessageKey* p = _impl_.key_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MessageKey&>(
      ::proto::_MessageKey_default_instance_);
}
inline const ::proto::MessageKey& WebMessageInfo::key() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.key)
  return _internal_key();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_key(
    ::proto::MessageKey* key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.key_);
  }
  _impl_.key_ = key;
  if (key) {
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.key)
}
inline ::proto::MessageKey* WebMessageInfo::release_key() {
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = 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 ::proto::MessageKey* WebMessageInfo::unsafe_arena_release_key() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.key)
  _impl_._has_bits_[0] &= ~0x00000100u;
  ::proto::MessageKey* temp = _impl_.key_;
  _impl_.key_ = nullptr;
  return temp;
}
inline ::proto::MessageKey* WebMessageInfo::_internal_mutable_key() {
  _impl_._has_bits_[0] |= 0x00000100u;
  if (_impl_.key_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MessageKey>(GetArenaForAllocation());
    _impl_.key_ = p;
  }
  return _impl_.key_;
}
inline ::proto::MessageKey* WebMessageInfo::mutable_key() {
  ::proto::MessageKey* _msg = _internal_mutable_key();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.key)
  return _msg;
}
inline void WebMessageInfo::set_allocated_key(::proto::MessageKey* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.key_;
  }
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(key);
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000100u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000100u;
  }
  _impl_.key_ = key;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.key)
}

// optional .proto.Message message = 2;
inline bool WebMessageInfo::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.message_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_message() const {
  return _internal_has_message();
}
inline void WebMessageInfo::clear_message() {
  if (_impl_.message_ != nullptr) _impl_.message_->Clear();
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline const ::proto::Message& WebMessageInfo::_internal_message() const {
  const ::proto::Message* p = _impl_.message_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message&>(
      ::proto::_Message_default_instance_);
}
inline const ::proto::Message& WebMessageInfo::message() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.message)
  return _internal_message();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_message(
    ::proto::Message* message) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.message_);
  }
  _impl_.message_ = message;
  if (message) {
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.message)
}
inline ::proto::Message* WebMessageInfo::release_message() {
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = 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 ::proto::Message* WebMessageInfo::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.message)
  _impl_._has_bits_[0] &= ~0x00000200u;
  ::proto::Message* temp = _impl_.message_;
  _impl_.message_ = nullptr;
  return temp;
}
inline ::proto::Message* WebMessageInfo::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000200u;
  if (_impl_.message_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message>(GetArenaForAllocation());
    _impl_.message_ = p;
  }
  return _impl_.message_;
}
inline ::proto::Message* WebMessageInfo::mutable_message() {
  ::proto::Message* _msg = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.message)
  return _msg;
}
inline void WebMessageInfo::set_allocated_message(::proto::Message* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(message);
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000200u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000200u;
  }
  _impl_.message_ = message;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.message)
}

// optional uint64 messageTimestamp = 3;
inline bool WebMessageInfo::_internal_has_messagetimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_messagetimestamp() const {
  return _internal_has_messagetimestamp();
}
inline void WebMessageInfo::clear_messagetimestamp() {
  _impl_.messagetimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint64_t WebMessageInfo::_internal_messagetimestamp() const {
  return _impl_.messagetimestamp_;
}
inline uint64_t WebMessageInfo::messagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageTimestamp)
  return _internal_messagetimestamp();
}
inline void WebMessageInfo::_internal_set_messagetimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.messagetimestamp_ = value;
}
inline void WebMessageInfo::set_messagetimestamp(uint64_t value) {
  _internal_set_messagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageTimestamp)
}

// optional .proto.WebMessageInfo.Status status = 4;
inline bool WebMessageInfo::_internal_has_status() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_status() const {
  return _internal_has_status();
}
inline void WebMessageInfo::clear_status() {
  _impl_.status_ = 0;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline ::proto::WebMessageInfo_Status WebMessageInfo::_internal_status() const {
  return static_cast< ::proto::WebMessageInfo_Status >(_impl_.status_);
}
inline ::proto::WebMessageInfo_Status WebMessageInfo::status() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.status)
  return _internal_status();
}
inline void WebMessageInfo::_internal_set_status(::proto::WebMessageInfo_Status value) {
  assert(::proto::WebMessageInfo_Status_IsValid(value));
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.status_ = value;
}
inline void WebMessageInfo::set_status(::proto::WebMessageInfo_Status value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.status)
}

// optional string participant = 5;
inline bool WebMessageInfo::_internal_has_participant() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WebMessageInfo::has_participant() const {
  return _internal_has_participant();
}
inline void WebMessageInfo::clear_participant() {
  _impl_.participant_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& WebMessageInfo::participant() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.participant)
  return _internal_participant();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_participant(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.participant_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.participant)
}
inline std::string* WebMessageInfo::mutable_participant() {
  std::string* _s = _internal_mutable_participant();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.participant)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_participant() const {
  return _impl_.participant_.Get();
}
inline void WebMessageInfo::_internal_set_participant(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.participant_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_participant() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.participant_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_participant() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.participant)
  if (!_internal_has_participant()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.participant_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_participant(std::string* participant) {
  if (participant != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.participant_.SetAllocated(participant, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.participant_.IsDefault()) {
    _impl_.participant_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.participant)
}

// optional uint64 messageC2STimestamp = 6;
inline bool WebMessageInfo::_internal_has_messagec2stimestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_messagec2stimestamp() const {
  return _internal_has_messagec2stimestamp();
}
inline void WebMessageInfo::clear_messagec2stimestamp() {
  _impl_.messagec2stimestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline uint64_t WebMessageInfo::_internal_messagec2stimestamp() const {
  return _impl_.messagec2stimestamp_;
}
inline uint64_t WebMessageInfo::messagec2stimestamp() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageC2STimestamp)
  return _internal_messagec2stimestamp();
}
inline void WebMessageInfo::_internal_set_messagec2stimestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.messagec2stimestamp_ = value;
}
inline void WebMessageInfo::set_messagec2stimestamp(uint64_t value) {
  _internal_set_messagec2stimestamp(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageC2STimestamp)
}

// optional bool ignore = 16;
inline bool WebMessageInfo::_internal_has_ignore() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_ignore() const {
  return _internal_has_ignore();
}
inline void WebMessageInfo::clear_ignore() {
  _impl_.ignore_ = false;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline bool WebMessageInfo::_internal_ignore() const {
  return _impl_.ignore_;
}
inline bool WebMessageInfo::ignore() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ignore)
  return _internal_ignore();
}
inline void WebMessageInfo::_internal_set_ignore(bool value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.ignore_ = value;
}
inline void WebMessageInfo::set_ignore(bool value) {
  _internal_set_ignore(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ignore)
}

// optional bool starred = 17;
inline bool WebMessageInfo::_internal_has_starred() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_starred() const {
  return _internal_has_starred();
}
inline void WebMessageInfo::clear_starred() {
  _impl_.starred_ = false;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline bool WebMessageInfo::_internal_starred() const {
  return _impl_.starred_;
}
inline bool WebMessageInfo::starred() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.starred)
  return _internal_starred();
}
inline void WebMessageInfo::_internal_set_starred(bool value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.starred_ = value;
}
inline void WebMessageInfo::set_starred(bool value) {
  _internal_set_starred(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.starred)
}

// optional bool broadcast = 18;
inline bool WebMessageInfo::_internal_has_broadcast() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_broadcast() const {
  return _internal_has_broadcast();
}
inline void WebMessageInfo::clear_broadcast() {
  _impl_.broadcast_ = false;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline bool WebMessageInfo::_internal_broadcast() const {
  return _impl_.broadcast_;
}
inline bool WebMessageInfo::broadcast() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.broadcast)
  return _internal_broadcast();
}
inline void WebMessageInfo::_internal_set_broadcast(bool value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.broadcast_ = value;
}
inline void WebMessageInfo::set_broadcast(bool value) {
  _internal_set_broadcast(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.broadcast)
}

// optional string pushName = 19;
inline bool WebMessageInfo::_internal_has_pushname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WebMessageInfo::has_pushname() const {
  return _internal_has_pushname();
}
inline void WebMessageInfo::clear_pushname() {
  _impl_.pushname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& WebMessageInfo::pushname() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pushName)
  return _internal_pushname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_pushname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.pushname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.pushName)
}
inline std::string* WebMessageInfo::mutable_pushname() {
  std::string* _s = _internal_mutable_pushname();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pushName)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_pushname() const {
  return _impl_.pushname_.Get();
}
inline void WebMessageInfo::_internal_set_pushname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pushname_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_pushname() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.pushname_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_pushname() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pushName)
  if (!_internal_has_pushname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.pushname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_pushname(std::string* pushname) {
  if (pushname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.pushname_.SetAllocated(pushname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pushname_.IsDefault()) {
    _impl_.pushname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pushName)
}

// optional bytes mediaCiphertextSha256 = 20;
inline bool WebMessageInfo::_internal_has_mediaciphertextsha256() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool WebMessageInfo::has_mediaciphertextsha256() const {
  return _internal_has_mediaciphertextsha256();
}
inline void WebMessageInfo::clear_mediaciphertextsha256() {
  _impl_.mediaciphertextsha256_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& WebMessageInfo::mediaciphertextsha256() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaCiphertextSha256)
  return _internal_mediaciphertextsha256();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_mediaciphertextsha256(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.mediaciphertextsha256_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.mediaCiphertextSha256)
}
inline std::string* WebMessageInfo::mutable_mediaciphertextsha256() {
  std::string* _s = _internal_mutable_mediaciphertextsha256();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaCiphertextSha256)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_mediaciphertextsha256() const {
  return _impl_.mediaciphertextsha256_.Get();
}
inline void WebMessageInfo::_internal_set_mediaciphertextsha256(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.mediaciphertextsha256_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_mediaciphertextsha256() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.mediaciphertextsha256_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_mediaciphertextsha256() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaCiphertextSha256)
  if (!_internal_has_mediaciphertextsha256()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.mediaciphertextsha256_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediaciphertextsha256_.IsDefault()) {
    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_mediaciphertextsha256(std::string* mediaciphertextsha256) {
  if (mediaciphertextsha256 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.mediaciphertextsha256_.SetAllocated(mediaciphertextsha256, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.mediaciphertextsha256_.IsDefault()) {
    _impl_.mediaciphertextsha256_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaCiphertextSha256)
}

// optional bool multicast = 21;
inline bool WebMessageInfo::_internal_has_multicast() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_multicast() const {
  return _internal_has_multicast();
}
inline void WebMessageInfo::clear_multicast() {
  _impl_.multicast_ = false;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline bool WebMessageInfo::_internal_multicast() const {
  return _impl_.multicast_;
}
inline bool WebMessageInfo::multicast() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.multicast)
  return _internal_multicast();
}
inline void WebMessageInfo::_internal_set_multicast(bool value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.multicast_ = value;
}
inline void WebMessageInfo::set_multicast(bool value) {
  _internal_set_multicast(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.multicast)
}

// optional bool urlText = 22;
inline bool WebMessageInfo::_internal_has_urltext() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_urltext() const {
  return _internal_has_urltext();
}
inline void WebMessageInfo::clear_urltext() {
  _impl_.urltext_ = false;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline bool WebMessageInfo::_internal_urltext() const {
  return _impl_.urltext_;
}
inline bool WebMessageInfo::urltext() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlText)
  return _internal_urltext();
}
inline void WebMessageInfo::_internal_set_urltext(bool value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.urltext_ = value;
}
inline void WebMessageInfo::set_urltext(bool value) {
  _internal_set_urltext(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlText)
}

// optional bool urlNumber = 23;
inline bool WebMessageInfo::_internal_has_urlnumber() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_urlnumber() const {
  return _internal_has_urlnumber();
}
inline void WebMessageInfo::clear_urlnumber() {
  _impl_.urlnumber_ = false;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline bool WebMessageInfo::_internal_urlnumber() const {
  return _impl_.urlnumber_;
}
inline bool WebMessageInfo::urlnumber() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.urlNumber)
  return _internal_urlnumber();
}
inline void WebMessageInfo::_internal_set_urlnumber(bool value) {
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.urlnumber_ = value;
}
inline void WebMessageInfo::set_urlnumber(bool value) {
  _internal_set_urlnumber(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.urlNumber)
}

// optional .proto.WebMessageInfo.StubType messageStubType = 24;
inline bool WebMessageInfo::_internal_has_messagestubtype() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_messagestubtype() const {
  return _internal_has_messagestubtype();
}
inline void WebMessageInfo::clear_messagestubtype() {
  _impl_.messagestubtype_ = 0;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline ::proto::WebMessageInfo_StubType WebMessageInfo::_internal_messagestubtype() const {
  return static_cast< ::proto::WebMessageInfo_StubType >(_impl_.messagestubtype_);
}
inline ::proto::WebMessageInfo_StubType WebMessageInfo::messagestubtype() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubType)
  return _internal_messagestubtype();
}
inline void WebMessageInfo::_internal_set_messagestubtype(::proto::WebMessageInfo_StubType value) {
  assert(::proto::WebMessageInfo_StubType_IsValid(value));
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.messagestubtype_ = value;
}
inline void WebMessageInfo::set_messagestubtype(::proto::WebMessageInfo_StubType value) {
  _internal_set_messagestubtype(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubType)
}

// optional bool clearMedia = 25;
inline bool WebMessageInfo::_internal_has_clearmedia() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_clearmedia() const {
  return _internal_has_clearmedia();
}
inline void WebMessageInfo::clear_clearmedia() {
  _impl_.clearmedia_ = false;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline bool WebMessageInfo::_internal_clearmedia() const {
  return _impl_.clearmedia_;
}
inline bool WebMessageInfo::clearmedia() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.clearMedia)
  return _internal_clearmedia();
}
inline void WebMessageInfo::_internal_set_clearmedia(bool value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.clearmedia_ = value;
}
inline void WebMessageInfo::set_clearmedia(bool value) {
  _internal_set_clearmedia(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.clearMedia)
}

// repeated string messageStubParameters = 26;
inline int WebMessageInfo::_internal_messagestubparameters_size() const {
  return _impl_.messagestubparameters_.size();
}
inline int WebMessageInfo::messagestubparameters_size() const {
  return _internal_messagestubparameters_size();
}
inline void WebMessageInfo::clear_messagestubparameters() {
  _impl_.messagestubparameters_.Clear();
}
inline std::string* WebMessageInfo::add_messagestubparameters() {
  std::string* _s = _internal_add_messagestubparameters();
  // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.messageStubParameters)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_messagestubparameters(int index) const {
  return _impl_.messagestubparameters_.Get(index);
}
inline const std::string& WebMessageInfo::messagestubparameters(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageStubParameters)
  return _internal_messagestubparameters(index);
}
inline std::string* WebMessageInfo::mutable_messagestubparameters(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageStubParameters)
  return _impl_.messagestubparameters_.Mutable(index);
}
inline void WebMessageInfo::set_messagestubparameters(int index, const std::string& value) {
  _impl_.messagestubparameters_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::set_messagestubparameters(int index, std::string&& value) {
  _impl_.messagestubparameters_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::set_messagestubparameters(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.messagestubparameters_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::set_messagestubparameters(int index, const char* value, size_t size) {
  _impl_.messagestubparameters_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.messageStubParameters)
}
inline std::string* WebMessageInfo::_internal_add_messagestubparameters() {
  return _impl_.messagestubparameters_.Add();
}
inline void WebMessageInfo::add_messagestubparameters(const std::string& value) {
  _impl_.messagestubparameters_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::add_messagestubparameters(std::string&& value) {
  _impl_.messagestubparameters_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::add_messagestubparameters(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.messagestubparameters_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.messageStubParameters)
}
inline void WebMessageInfo::add_messagestubparameters(const char* value, size_t size) {
  _impl_.messagestubparameters_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.messageStubParameters)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
WebMessageInfo::messagestubparameters() const {
  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.messageStubParameters)
  return _impl_.messagestubparameters_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
WebMessageInfo::mutable_messagestubparameters() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.messageStubParameters)
  return &_impl_.messagestubparameters_;
}

// optional uint32 duration = 27;
inline bool WebMessageInfo::_internal_has_duration() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_duration() const {
  return _internal_has_duration();
}
inline void WebMessageInfo::clear_duration() {
  _impl_.duration_ = 0u;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline uint32_t WebMessageInfo::_internal_duration() const {
  return _impl_.duration_;
}
inline uint32_t WebMessageInfo::duration() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.duration)
  return _internal_duration();
}
inline void WebMessageInfo::_internal_set_duration(uint32_t value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.duration_ = value;
}
inline void WebMessageInfo::set_duration(uint32_t value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.duration)
}

// repeated string labels = 28;
inline int WebMessageInfo::_internal_labels_size() const {
  return _impl_.labels_.size();
}
inline int WebMessageInfo::labels_size() const {
  return _internal_labels_size();
}
inline void WebMessageInfo::clear_labels() {
  _impl_.labels_.Clear();
}
inline std::string* WebMessageInfo::add_labels() {
  std::string* _s = _internal_add_labels();
  // @@protoc_insertion_point(field_add_mutable:proto.WebMessageInfo.labels)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_labels(int index) const {
  return _impl_.labels_.Get(index);
}
inline const std::string& WebMessageInfo::labels(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.labels)
  return _internal_labels(index);
}
inline std::string* WebMessageInfo::mutable_labels(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.labels)
  return _impl_.labels_.Mutable(index);
}
inline void WebMessageInfo::set_labels(int index, const std::string& value) {
  _impl_.labels_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::set_labels(int index, std::string&& value) {
  _impl_.labels_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::set_labels(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.labels_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::set_labels(int index, const char* value, size_t size) {
  _impl_.labels_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:proto.WebMessageInfo.labels)
}
inline std::string* WebMessageInfo::_internal_add_labels() {
  return _impl_.labels_.Add();
}
inline void WebMessageInfo::add_labels(const std::string& value) {
  _impl_.labels_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::add_labels(std::string&& value) {
  _impl_.labels_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::add_labels(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _impl_.labels_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:proto.WebMessageInfo.labels)
}
inline void WebMessageInfo::add_labels(const char* value, size_t size) {
  _impl_.labels_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:proto.WebMessageInfo.labels)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
WebMessageInfo::labels() const {
  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.labels)
  return _impl_.labels_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
WebMessageInfo::mutable_labels() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.labels)
  return &_impl_.labels_;
}

// optional .proto.PaymentInfo paymentInfo = 29;
inline bool WebMessageInfo::_internal_has_paymentinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.paymentinfo_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_paymentinfo() const {
  return _internal_has_paymentinfo();
}
inline void WebMessageInfo::clear_paymentinfo() {
  if (_impl_.paymentinfo_ != nullptr) _impl_.paymentinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline const ::proto::PaymentInfo& WebMessageInfo::_internal_paymentinfo() const {
  const ::proto::PaymentInfo* p = _impl_.paymentinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentInfo&>(
      ::proto::_PaymentInfo_default_instance_);
}
inline const ::proto::PaymentInfo& WebMessageInfo::paymentinfo() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.paymentInfo)
  return _internal_paymentinfo();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_paymentinfo(
    ::proto::PaymentInfo* paymentinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.paymentinfo_);
  }
  _impl_.paymentinfo_ = paymentinfo;
  if (paymentinfo) {
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.paymentInfo)
}
inline ::proto::PaymentInfo* WebMessageInfo::release_paymentinfo() {
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::PaymentInfo* temp = _impl_.paymentinfo_;
  _impl_.paymentinfo_ = 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 ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_paymentinfo() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.paymentInfo)
  _impl_._has_bits_[0] &= ~0x00000400u;
  ::proto::PaymentInfo* temp = _impl_.paymentinfo_;
  _impl_.paymentinfo_ = nullptr;
  return temp;
}
inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_paymentinfo() {
  _impl_._has_bits_[0] |= 0x00000400u;
  if (_impl_.paymentinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation());
    _impl_.paymentinfo_ = p;
  }
  return _impl_.paymentinfo_;
}
inline ::proto::PaymentInfo* WebMessageInfo::mutable_paymentinfo() {
  ::proto::PaymentInfo* _msg = _internal_mutable_paymentinfo();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.paymentInfo)
  return _msg;
}
inline void WebMessageInfo::set_allocated_paymentinfo(::proto::PaymentInfo* paymentinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.paymentinfo_;
  }
  if (paymentinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paymentinfo);
    if (message_arena != submessage_arena) {
      paymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paymentinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000400u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000400u;
  }
  _impl_.paymentinfo_ = paymentinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.paymentInfo)
}

// optional .proto.Message.LiveLocationMessage finalLiveLocation = 30;
inline bool WebMessageInfo::_internal_has_finallivelocation() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.finallivelocation_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_finallivelocation() const {
  return _internal_has_finallivelocation();
}
inline void WebMessageInfo::clear_finallivelocation() {
  if (_impl_.finallivelocation_ != nullptr) _impl_.finallivelocation_->Clear();
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::_internal_finallivelocation() const {
  const ::proto::Message_LiveLocationMessage* p = _impl_.finallivelocation_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::Message_LiveLocationMessage&>(
      ::proto::_Message_LiveLocationMessage_default_instance_);
}
inline const ::proto::Message_LiveLocationMessage& WebMessageInfo::finallivelocation() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.finalLiveLocation)
  return _internal_finallivelocation();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_finallivelocation(
    ::proto::Message_LiveLocationMessage* finallivelocation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.finallivelocation_);
  }
  _impl_.finallivelocation_ = finallivelocation;
  if (finallivelocation) {
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.finalLiveLocation)
}
inline ::proto::Message_LiveLocationMessage* WebMessageInfo::release_finallivelocation() {
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_;
  _impl_.finallivelocation_ = 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 ::proto::Message_LiveLocationMessage* WebMessageInfo::unsafe_arena_release_finallivelocation() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.finalLiveLocation)
  _impl_._has_bits_[0] &= ~0x00000800u;
  ::proto::Message_LiveLocationMessage* temp = _impl_.finallivelocation_;
  _impl_.finallivelocation_ = nullptr;
  return temp;
}
inline ::proto::Message_LiveLocationMessage* WebMessageInfo::_internal_mutable_finallivelocation() {
  _impl_._has_bits_[0] |= 0x00000800u;
  if (_impl_.finallivelocation_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::Message_LiveLocationMessage>(GetArenaForAllocation());
    _impl_.finallivelocation_ = p;
  }
  return _impl_.finallivelocation_;
}
inline ::proto::Message_LiveLocationMessage* WebMessageInfo::mutable_finallivelocation() {
  ::proto::Message_LiveLocationMessage* _msg = _internal_mutable_finallivelocation();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.finalLiveLocation)
  return _msg;
}
inline void WebMessageInfo::set_allocated_finallivelocation(::proto::Message_LiveLocationMessage* finallivelocation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.finallivelocation_;
  }
  if (finallivelocation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(finallivelocation);
    if (message_arena != submessage_arena) {
      finallivelocation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, finallivelocation, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000800u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000800u;
  }
  _impl_.finallivelocation_ = finallivelocation;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.finalLiveLocation)
}

// optional .proto.PaymentInfo quotedPaymentInfo = 31;
inline bool WebMessageInfo::_internal_has_quotedpaymentinfo() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quotedpaymentinfo_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_quotedpaymentinfo() const {
  return _internal_has_quotedpaymentinfo();
}
inline void WebMessageInfo::clear_quotedpaymentinfo() {
  if (_impl_.quotedpaymentinfo_ != nullptr) _impl_.quotedpaymentinfo_->Clear();
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline const ::proto::PaymentInfo& WebMessageInfo::_internal_quotedpaymentinfo() const {
  const ::proto::PaymentInfo* p = _impl_.quotedpaymentinfo_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PaymentInfo&>(
      ::proto::_PaymentInfo_default_instance_);
}
inline const ::proto::PaymentInfo& WebMessageInfo::quotedpaymentinfo() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedPaymentInfo)
  return _internal_quotedpaymentinfo();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_quotedpaymentinfo(
    ::proto::PaymentInfo* quotedpaymentinfo) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedpaymentinfo_);
  }
  _impl_.quotedpaymentinfo_ = quotedpaymentinfo;
  if (quotedpaymentinfo) {
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedPaymentInfo)
}
inline ::proto::PaymentInfo* WebMessageInfo::release_quotedpaymentinfo() {
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_;
  _impl_.quotedpaymentinfo_ = 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 ::proto::PaymentInfo* WebMessageInfo::unsafe_arena_release_quotedpaymentinfo() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedPaymentInfo)
  _impl_._has_bits_[0] &= ~0x00001000u;
  ::proto::PaymentInfo* temp = _impl_.quotedpaymentinfo_;
  _impl_.quotedpaymentinfo_ = nullptr;
  return temp;
}
inline ::proto::PaymentInfo* WebMessageInfo::_internal_mutable_quotedpaymentinfo() {
  _impl_._has_bits_[0] |= 0x00001000u;
  if (_impl_.quotedpaymentinfo_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PaymentInfo>(GetArenaForAllocation());
    _impl_.quotedpaymentinfo_ = p;
  }
  return _impl_.quotedpaymentinfo_;
}
inline ::proto::PaymentInfo* WebMessageInfo::mutable_quotedpaymentinfo() {
  ::proto::PaymentInfo* _msg = _internal_mutable_quotedpaymentinfo();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedPaymentInfo)
  return _msg;
}
inline void WebMessageInfo::set_allocated_quotedpaymentinfo(::proto::PaymentInfo* quotedpaymentinfo) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quotedpaymentinfo_;
  }
  if (quotedpaymentinfo) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedpaymentinfo);
    if (message_arena != submessage_arena) {
      quotedpaymentinfo = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quotedpaymentinfo, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00001000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00001000u;
  }
  _impl_.quotedpaymentinfo_ = quotedpaymentinfo;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedPaymentInfo)
}

// optional uint64 ephemeralStartTimestamp = 32;
inline bool WebMessageInfo::_internal_has_ephemeralstarttimestamp() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool WebMessageInfo::has_ephemeralstarttimestamp() const {
  return _internal_has_ephemeralstarttimestamp();
}
inline void WebMessageInfo::clear_ephemeralstarttimestamp() {
  _impl_.ephemeralstarttimestamp_ = uint64_t{0u};
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline uint64_t WebMessageInfo::_internal_ephemeralstarttimestamp() const {
  return _impl_.ephemeralstarttimestamp_;
}
inline uint64_t WebMessageInfo::ephemeralstarttimestamp() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralStartTimestamp)
  return _internal_ephemeralstarttimestamp();
}
inline void WebMessageInfo::_internal_set_ephemeralstarttimestamp(uint64_t value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.ephemeralstarttimestamp_ = value;
}
inline void WebMessageInfo::set_ephemeralstarttimestamp(uint64_t value) {
  _internal_set_ephemeralstarttimestamp(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralStartTimestamp)
}

// optional uint32 ephemeralDuration = 33;
inline bool WebMessageInfo::_internal_has_ephemeralduration() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool WebMessageInfo::has_ephemeralduration() const {
  return _internal_has_ephemeralduration();
}
inline void WebMessageInfo::clear_ephemeralduration() {
  _impl_.ephemeralduration_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline uint32_t WebMessageInfo::_internal_ephemeralduration() const {
  return _impl_.ephemeralduration_;
}
inline uint32_t WebMessageInfo::ephemeralduration() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralDuration)
  return _internal_ephemeralduration();
}
inline void WebMessageInfo::_internal_set_ephemeralduration(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.ephemeralduration_ = value;
}
inline void WebMessageInfo::set_ephemeralduration(uint32_t value) {
  _internal_set_ephemeralduration(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralDuration)
}

// optional bool ephemeralOffToOn = 34;
inline bool WebMessageInfo::_internal_has_ephemeralofftoon() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool WebMessageInfo::has_ephemeralofftoon() const {
  return _internal_has_ephemeralofftoon();
}
inline void WebMessageInfo::clear_ephemeralofftoon() {
  _impl_.ephemeralofftoon_ = false;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline bool WebMessageInfo::_internal_ephemeralofftoon() const {
  return _impl_.ephemeralofftoon_;
}
inline bool WebMessageInfo::ephemeralofftoon() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOffToOn)
  return _internal_ephemeralofftoon();
}
inline void WebMessageInfo::_internal_set_ephemeralofftoon(bool value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.ephemeralofftoon_ = value;
}
inline void WebMessageInfo::set_ephemeralofftoon(bool value) {
  _internal_set_ephemeralofftoon(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOffToOn)
}

// optional bool ephemeralOutOfSync = 35;
inline bool WebMessageInfo::_internal_has_ephemeraloutofsync() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool WebMessageInfo::has_ephemeraloutofsync() const {
  return _internal_has_ephemeraloutofsync();
}
inline void WebMessageInfo::clear_ephemeraloutofsync() {
  _impl_.ephemeraloutofsync_ = false;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline bool WebMessageInfo::_internal_ephemeraloutofsync() const {
  return _impl_.ephemeraloutofsync_;
}
inline bool WebMessageInfo::ephemeraloutofsync() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.ephemeralOutOfSync)
  return _internal_ephemeraloutofsync();
}
inline void WebMessageInfo::_internal_set_ephemeraloutofsync(bool value) {
  _impl_._has_bits_[1] |= 0x00000008u;
  _impl_.ephemeraloutofsync_ = value;
}
inline void WebMessageInfo::set_ephemeraloutofsync(bool value) {
  _internal_set_ephemeraloutofsync(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.ephemeralOutOfSync)
}

// optional .proto.WebMessageInfo.BizPrivacyStatus bizPrivacyStatus = 36;
inline bool WebMessageInfo::_internal_has_bizprivacystatus() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool WebMessageInfo::has_bizprivacystatus() const {
  return _internal_has_bizprivacystatus();
}
inline void WebMessageInfo::clear_bizprivacystatus() {
  _impl_.bizprivacystatus_ = 0;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::_internal_bizprivacystatus() const {
  return static_cast< ::proto::WebMessageInfo_BizPrivacyStatus >(_impl_.bizprivacystatus_);
}
inline ::proto::WebMessageInfo_BizPrivacyStatus WebMessageInfo::bizprivacystatus() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.bizPrivacyStatus)
  return _internal_bizprivacystatus();
}
inline void WebMessageInfo::_internal_set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) {
  assert(::proto::WebMessageInfo_BizPrivacyStatus_IsValid(value));
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.bizprivacystatus_ = value;
}
inline void WebMessageInfo::set_bizprivacystatus(::proto::WebMessageInfo_BizPrivacyStatus value) {
  _internal_set_bizprivacystatus(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.bizPrivacyStatus)
}

// optional string verifiedBizName = 37;
inline bool WebMessageInfo::_internal_has_verifiedbizname() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool WebMessageInfo::has_verifiedbizname() const {
  return _internal_has_verifiedbizname();
}
inline void WebMessageInfo::clear_verifiedbizname() {
  _impl_.verifiedbizname_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& WebMessageInfo::verifiedbizname() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.verifiedBizName)
  return _internal_verifiedbizname();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_verifiedbizname(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.verifiedbizname_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.verifiedBizName)
}
inline std::string* WebMessageInfo::mutable_verifiedbizname() {
  std::string* _s = _internal_mutable_verifiedbizname();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.verifiedBizName)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_verifiedbizname() const {
  return _impl_.verifiedbizname_.Get();
}
inline void WebMessageInfo::_internal_set_verifiedbizname(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.verifiedbizname_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_verifiedbizname() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.verifiedbizname_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_verifiedbizname() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.verifiedBizName)
  if (!_internal_has_verifiedbizname()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.verifiedbizname_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedbizname_.IsDefault()) {
    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_verifiedbizname(std::string* verifiedbizname) {
  if (verifiedbizname != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.verifiedbizname_.SetAllocated(verifiedbizname, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.verifiedbizname_.IsDefault()) {
    _impl_.verifiedbizname_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.verifiedBizName)
}

// optional .proto.MediaData mediaData = 38;
inline bool WebMessageInfo::_internal_has_mediadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.mediadata_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_mediadata() const {
  return _internal_has_mediadata();
}
inline void WebMessageInfo::clear_mediadata() {
  if (_impl_.mediadata_ != nullptr) _impl_.mediadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline const ::proto::MediaData& WebMessageInfo::_internal_mediadata() const {
  const ::proto::MediaData* p = _impl_.mediadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MediaData&>(
      ::proto::_MediaData_default_instance_);
}
inline const ::proto::MediaData& WebMessageInfo::mediadata() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.mediaData)
  return _internal_mediadata();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_mediadata(
    ::proto::MediaData* mediadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.mediadata_);
  }
  _impl_.mediadata_ = mediadata;
  if (mediadata) {
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.mediaData)
}
inline ::proto::MediaData* WebMessageInfo::release_mediadata() {
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::MediaData* temp = _impl_.mediadata_;
  _impl_.mediadata_ = 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 ::proto::MediaData* WebMessageInfo::unsafe_arena_release_mediadata() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.mediaData)
  _impl_._has_bits_[0] &= ~0x00002000u;
  ::proto::MediaData* temp = _impl_.mediadata_;
  _impl_.mediadata_ = nullptr;
  return temp;
}
inline ::proto::MediaData* WebMessageInfo::_internal_mutable_mediadata() {
  _impl_._has_bits_[0] |= 0x00002000u;
  if (_impl_.mediadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation());
    _impl_.mediadata_ = p;
  }
  return _impl_.mediadata_;
}
inline ::proto::MediaData* WebMessageInfo::mutable_mediadata() {
  ::proto::MediaData* _msg = _internal_mutable_mediadata();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.mediaData)
  return _msg;
}
inline void WebMessageInfo::set_allocated_mediadata(::proto::MediaData* mediadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.mediadata_;
  }
  if (mediadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(mediadata);
    if (message_arena != submessage_arena) {
      mediadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mediadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00002000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00002000u;
  }
  _impl_.mediadata_ = mediadata;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.mediaData)
}

// optional .proto.PhotoChange photoChange = 39;
inline bool WebMessageInfo::_internal_has_photochange() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.photochange_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_photochange() const {
  return _internal_has_photochange();
}
inline void WebMessageInfo::clear_photochange() {
  if (_impl_.photochange_ != nullptr) _impl_.photochange_->Clear();
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline const ::proto::PhotoChange& WebMessageInfo::_internal_photochange() const {
  const ::proto::PhotoChange* p = _impl_.photochange_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PhotoChange&>(
      ::proto::_PhotoChange_default_instance_);
}
inline const ::proto::PhotoChange& WebMessageInfo::photochange() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.photoChange)
  return _internal_photochange();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_photochange(
    ::proto::PhotoChange* photochange) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.photochange_);
  }
  _impl_.photochange_ = photochange;
  if (photochange) {
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.photoChange)
}
inline ::proto::PhotoChange* WebMessageInfo::release_photochange() {
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::PhotoChange* temp = _impl_.photochange_;
  _impl_.photochange_ = 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 ::proto::PhotoChange* WebMessageInfo::unsafe_arena_release_photochange() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.photoChange)
  _impl_._has_bits_[0] &= ~0x00004000u;
  ::proto::PhotoChange* temp = _impl_.photochange_;
  _impl_.photochange_ = nullptr;
  return temp;
}
inline ::proto::PhotoChange* WebMessageInfo::_internal_mutable_photochange() {
  _impl_._has_bits_[0] |= 0x00004000u;
  if (_impl_.photochange_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PhotoChange>(GetArenaForAllocation());
    _impl_.photochange_ = p;
  }
  return _impl_.photochange_;
}
inline ::proto::PhotoChange* WebMessageInfo::mutable_photochange() {
  ::proto::PhotoChange* _msg = _internal_mutable_photochange();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.photoChange)
  return _msg;
}
inline void WebMessageInfo::set_allocated_photochange(::proto::PhotoChange* photochange) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.photochange_;
  }
  if (photochange) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(photochange);
    if (message_arena != submessage_arena) {
      photochange = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, photochange, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00004000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00004000u;
  }
  _impl_.photochange_ = photochange;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.photoChange)
}

// repeated .proto.UserReceipt userReceipt = 40;
inline int WebMessageInfo::_internal_userreceipt_size() const {
  return _impl_.userreceipt_.size();
}
inline int WebMessageInfo::userreceipt_size() const {
  return _internal_userreceipt_size();
}
inline void WebMessageInfo::clear_userreceipt() {
  _impl_.userreceipt_.Clear();
}
inline ::proto::UserReceipt* WebMessageInfo::mutable_userreceipt(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.userReceipt)
  return _impl_.userreceipt_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >*
WebMessageInfo::mutable_userreceipt() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.userReceipt)
  return &_impl_.userreceipt_;
}
inline const ::proto::UserReceipt& WebMessageInfo::_internal_userreceipt(int index) const {
  return _impl_.userreceipt_.Get(index);
}
inline const ::proto::UserReceipt& WebMessageInfo::userreceipt(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.userReceipt)
  return _internal_userreceipt(index);
}
inline ::proto::UserReceipt* WebMessageInfo::_internal_add_userreceipt() {
  return _impl_.userreceipt_.Add();
}
inline ::proto::UserReceipt* WebMessageInfo::add_userreceipt() {
  ::proto::UserReceipt* _add = _internal_add_userreceipt();
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.userReceipt)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::UserReceipt >&
WebMessageInfo::userreceipt() const {
  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.userReceipt)
  return _impl_.userreceipt_;
}

// repeated .proto.Reaction reactions = 41;
inline int WebMessageInfo::_internal_reactions_size() const {
  return _impl_.reactions_.size();
}
inline int WebMessageInfo::reactions_size() const {
  return _internal_reactions_size();
}
inline void WebMessageInfo::clear_reactions() {
  _impl_.reactions_.Clear();
}
inline ::proto::Reaction* WebMessageInfo::mutable_reactions(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.reactions)
  return _impl_.reactions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >*
WebMessageInfo::mutable_reactions() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.reactions)
  return &_impl_.reactions_;
}
inline const ::proto::Reaction& WebMessageInfo::_internal_reactions(int index) const {
  return _impl_.reactions_.Get(index);
}
inline const ::proto::Reaction& WebMessageInfo::reactions(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.reactions)
  return _internal_reactions(index);
}
inline ::proto::Reaction* WebMessageInfo::_internal_add_reactions() {
  return _impl_.reactions_.Add();
}
inline ::proto::Reaction* WebMessageInfo::add_reactions() {
  ::proto::Reaction* _add = _internal_add_reactions();
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.reactions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::Reaction >&
WebMessageInfo::reactions() const {
  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.reactions)
  return _impl_.reactions_;
}

// optional .proto.MediaData quotedStickerData = 42;
inline bool WebMessageInfo::_internal_has_quotedstickerdata() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quotedstickerdata_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_quotedstickerdata() const {
  return _internal_has_quotedstickerdata();
}
inline void WebMessageInfo::clear_quotedstickerdata() {
  if (_impl_.quotedstickerdata_ != nullptr) _impl_.quotedstickerdata_->Clear();
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline const ::proto::MediaData& WebMessageInfo::_internal_quotedstickerdata() const {
  const ::proto::MediaData* p = _impl_.quotedstickerdata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::MediaData&>(
      ::proto::_MediaData_default_instance_);
}
inline const ::proto::MediaData& WebMessageInfo::quotedstickerdata() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.quotedStickerData)
  return _internal_quotedstickerdata();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_quotedstickerdata(
    ::proto::MediaData* quotedstickerdata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quotedstickerdata_);
  }
  _impl_.quotedstickerdata_ = quotedstickerdata;
  if (quotedstickerdata) {
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.quotedStickerData)
}
inline ::proto::MediaData* WebMessageInfo::release_quotedstickerdata() {
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::MediaData* temp = _impl_.quotedstickerdata_;
  _impl_.quotedstickerdata_ = 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 ::proto::MediaData* WebMessageInfo::unsafe_arena_release_quotedstickerdata() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.quotedStickerData)
  _impl_._has_bits_[0] &= ~0x00008000u;
  ::proto::MediaData* temp = _impl_.quotedstickerdata_;
  _impl_.quotedstickerdata_ = nullptr;
  return temp;
}
inline ::proto::MediaData* WebMessageInfo::_internal_mutable_quotedstickerdata() {
  _impl_._has_bits_[0] |= 0x00008000u;
  if (_impl_.quotedstickerdata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::MediaData>(GetArenaForAllocation());
    _impl_.quotedstickerdata_ = p;
  }
  return _impl_.quotedstickerdata_;
}
inline ::proto::MediaData* WebMessageInfo::mutable_quotedstickerdata() {
  ::proto::MediaData* _msg = _internal_mutable_quotedstickerdata();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.quotedStickerData)
  return _msg;
}
inline void WebMessageInfo::set_allocated_quotedstickerdata(::proto::MediaData* quotedstickerdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.quotedstickerdata_;
  }
  if (quotedstickerdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(quotedstickerdata);
    if (message_arena != submessage_arena) {
      quotedstickerdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quotedstickerdata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00008000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00008000u;
  }
  _impl_.quotedstickerdata_ = quotedstickerdata;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.quotedStickerData)
}

// optional bytes futureproofData = 43;
inline bool WebMessageInfo::_internal_has_futureproofdata() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool WebMessageInfo::has_futureproofdata() const {
  return _internal_has_futureproofdata();
}
inline void WebMessageInfo::clear_futureproofdata() {
  _impl_.futureproofdata_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& WebMessageInfo::futureproofdata() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.futureproofData)
  return _internal_futureproofdata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_futureproofdata(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.futureproofdata_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.futureproofData)
}
inline std::string* WebMessageInfo::mutable_futureproofdata() {
  std::string* _s = _internal_mutable_futureproofdata();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.futureproofData)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_futureproofdata() const {
  return _impl_.futureproofdata_.Get();
}
inline void WebMessageInfo::_internal_set_futureproofdata(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.futureproofdata_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_futureproofdata() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.futureproofdata_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_futureproofdata() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.futureproofData)
  if (!_internal_has_futureproofdata()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.futureproofdata_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.futureproofdata_.IsDefault()) {
    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_futureproofdata(std::string* futureproofdata) {
  if (futureproofdata != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.futureproofdata_.SetAllocated(futureproofdata, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.futureproofdata_.IsDefault()) {
    _impl_.futureproofdata_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.futureproofData)
}

// optional .proto.StatusPSA statusPsa = 44;
inline bool WebMessageInfo::_internal_has_statuspsa() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.statuspsa_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_statuspsa() const {
  return _internal_has_statuspsa();
}
inline void WebMessageInfo::clear_statuspsa() {
  if (_impl_.statuspsa_ != nullptr) _impl_.statuspsa_->Clear();
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline const ::proto::StatusPSA& WebMessageInfo::_internal_statuspsa() const {
  const ::proto::StatusPSA* p = _impl_.statuspsa_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::StatusPSA&>(
      ::proto::_StatusPSA_default_instance_);
}
inline const ::proto::StatusPSA& WebMessageInfo::statuspsa() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusPsa)
  return _internal_statuspsa();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_statuspsa(
    ::proto::StatusPSA* statuspsa) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.statuspsa_);
  }
  _impl_.statuspsa_ = statuspsa;
  if (statuspsa) {
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.statusPsa)
}
inline ::proto::StatusPSA* WebMessageInfo::release_statuspsa() {
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::StatusPSA* temp = _impl_.statuspsa_;
  _impl_.statuspsa_ = 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 ::proto::StatusPSA* WebMessageInfo::unsafe_arena_release_statuspsa() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.statusPsa)
  _impl_._has_bits_[0] &= ~0x00010000u;
  ::proto::StatusPSA* temp = _impl_.statuspsa_;
  _impl_.statuspsa_ = nullptr;
  return temp;
}
inline ::proto::StatusPSA* WebMessageInfo::_internal_mutable_statuspsa() {
  _impl_._has_bits_[0] |= 0x00010000u;
  if (_impl_.statuspsa_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::StatusPSA>(GetArenaForAllocation());
    _impl_.statuspsa_ = p;
  }
  return _impl_.statuspsa_;
}
inline ::proto::StatusPSA* WebMessageInfo::mutable_statuspsa() {
  ::proto::StatusPSA* _msg = _internal_mutable_statuspsa();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.statusPsa)
  return _msg;
}
inline void WebMessageInfo::set_allocated_statuspsa(::proto::StatusPSA* statuspsa) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.statuspsa_;
  }
  if (statuspsa) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(statuspsa);
    if (message_arena != submessage_arena) {
      statuspsa = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, statuspsa, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00010000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00010000u;
  }
  _impl_.statuspsa_ = statuspsa;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.statusPsa)
}

// repeated .proto.PollUpdate pollUpdates = 45;
inline int WebMessageInfo::_internal_pollupdates_size() const {
  return _impl_.pollupdates_.size();
}
inline int WebMessageInfo::pollupdates_size() const {
  return _internal_pollupdates_size();
}
inline void WebMessageInfo::clear_pollupdates() {
  _impl_.pollupdates_.Clear();
}
inline ::proto::PollUpdate* WebMessageInfo::mutable_pollupdates(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollUpdates)
  return _impl_.pollupdates_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >*
WebMessageInfo::mutable_pollupdates() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebMessageInfo.pollUpdates)
  return &_impl_.pollupdates_;
}
inline const ::proto::PollUpdate& WebMessageInfo::_internal_pollupdates(int index) const {
  return _impl_.pollupdates_.Get(index);
}
inline const ::proto::PollUpdate& WebMessageInfo::pollupdates(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollUpdates)
  return _internal_pollupdates(index);
}
inline ::proto::PollUpdate* WebMessageInfo::_internal_add_pollupdates() {
  return _impl_.pollupdates_.Add();
}
inline ::proto::PollUpdate* WebMessageInfo::add_pollupdates() {
  ::proto::PollUpdate* _add = _internal_add_pollupdates();
  // @@protoc_insertion_point(field_add:proto.WebMessageInfo.pollUpdates)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::PollUpdate >&
WebMessageInfo::pollupdates() const {
  // @@protoc_insertion_point(field_list:proto.WebMessageInfo.pollUpdates)
  return _impl_.pollupdates_;
}

// optional .proto.PollAdditionalMetadata pollAdditionalMetadata = 46;
inline bool WebMessageInfo::_internal_has_polladditionalmetadata() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.polladditionalmetadata_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_polladditionalmetadata() const {
  return _internal_has_polladditionalmetadata();
}
inline void WebMessageInfo::clear_polladditionalmetadata() {
  if (_impl_.polladditionalmetadata_ != nullptr) _impl_.polladditionalmetadata_->Clear();
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline const ::proto::PollAdditionalMetadata& WebMessageInfo::_internal_polladditionalmetadata() const {
  const ::proto::PollAdditionalMetadata* p = _impl_.polladditionalmetadata_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::PollAdditionalMetadata&>(
      ::proto::_PollAdditionalMetadata_default_instance_);
}
inline const ::proto::PollAdditionalMetadata& WebMessageInfo::polladditionalmetadata() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.pollAdditionalMetadata)
  return _internal_polladditionalmetadata();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_polladditionalmetadata(
    ::proto::PollAdditionalMetadata* polladditionalmetadata) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.polladditionalmetadata_);
  }
  _impl_.polladditionalmetadata_ = polladditionalmetadata;
  if (polladditionalmetadata) {
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata)
}
inline ::proto::PollAdditionalMetadata* WebMessageInfo::release_polladditionalmetadata() {
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_;
  _impl_.polladditionalmetadata_ = 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 ::proto::PollAdditionalMetadata* WebMessageInfo::unsafe_arena_release_polladditionalmetadata() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.pollAdditionalMetadata)
  _impl_._has_bits_[0] &= ~0x00020000u;
  ::proto::PollAdditionalMetadata* temp = _impl_.polladditionalmetadata_;
  _impl_.polladditionalmetadata_ = nullptr;
  return temp;
}
inline ::proto::PollAdditionalMetadata* WebMessageInfo::_internal_mutable_polladditionalmetadata() {
  _impl_._has_bits_[0] |= 0x00020000u;
  if (_impl_.polladditionalmetadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::PollAdditionalMetadata>(GetArenaForAllocation());
    _impl_.polladditionalmetadata_ = p;
  }
  return _impl_.polladditionalmetadata_;
}
inline ::proto::PollAdditionalMetadata* WebMessageInfo::mutable_polladditionalmetadata() {
  ::proto::PollAdditionalMetadata* _msg = _internal_mutable_polladditionalmetadata();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.pollAdditionalMetadata)
  return _msg;
}
inline void WebMessageInfo::set_allocated_polladditionalmetadata(::proto::PollAdditionalMetadata* polladditionalmetadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.polladditionalmetadata_;
  }
  if (polladditionalmetadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(polladditionalmetadata);
    if (message_arena != submessage_arena) {
      polladditionalmetadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, polladditionalmetadata, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00020000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00020000u;
  }
  _impl_.polladditionalmetadata_ = polladditionalmetadata;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.pollAdditionalMetadata)
}

// optional string agentId = 47;
inline bool WebMessageInfo::_internal_has_agentid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool WebMessageInfo::has_agentid() const {
  return _internal_has_agentid();
}
inline void WebMessageInfo::clear_agentid() {
  _impl_.agentid_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const std::string& WebMessageInfo::agentid() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.agentId)
  return _internal_agentid();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_agentid(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000020u;
 _impl_.agentid_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.agentId)
}
inline std::string* WebMessageInfo::mutable_agentid() {
  std::string* _s = _internal_mutable_agentid();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.agentId)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_agentid() const {
  return _impl_.agentid_.Get();
}
inline void WebMessageInfo::_internal_set_agentid(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.agentid_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_agentid() {
  _impl_._has_bits_[0] |= 0x00000020u;
  return _impl_.agentid_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_agentid() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.agentId)
  if (!_internal_has_agentid()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000020u;
  auto* p = _impl_.agentid_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.agentid_.IsDefault()) {
    _impl_.agentid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_agentid(std::string* agentid) {
  if (agentid != nullptr) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.agentid_.SetAllocated(agentid, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.agentid_.IsDefault()) {
    _impl_.agentid_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.agentId)
}

// optional bool statusAlreadyViewed = 48;
inline bool WebMessageInfo::_internal_has_statusalreadyviewed() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool WebMessageInfo::has_statusalreadyviewed() const {
  return _internal_has_statusalreadyviewed();
}
inline void WebMessageInfo::clear_statusalreadyviewed() {
  _impl_.statusalreadyviewed_ = false;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline bool WebMessageInfo::_internal_statusalreadyviewed() const {
  return _impl_.statusalreadyviewed_;
}
inline bool WebMessageInfo::statusalreadyviewed() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.statusAlreadyViewed)
  return _internal_statusalreadyviewed();
}
inline void WebMessageInfo::_internal_set_statusalreadyviewed(bool value) {
  _impl_._has_bits_[1] |= 0x00000010u;
  _impl_.statusalreadyviewed_ = value;
}
inline void WebMessageInfo::set_statusalreadyviewed(bool value) {
  _internal_set_statusalreadyviewed(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.statusAlreadyViewed)
}

// optional bytes messageSecret = 49;
inline bool WebMessageInfo::_internal_has_messagesecret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool WebMessageInfo::has_messagesecret() const {
  return _internal_has_messagesecret();
}
inline void WebMessageInfo::clear_messagesecret() {
  _impl_.messagesecret_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const std::string& WebMessageInfo::messagesecret() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.messageSecret)
  return _internal_messagesecret();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_messagesecret(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000040u;
 _impl_.messagesecret_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.messageSecret)
}
inline std::string* WebMessageInfo::mutable_messagesecret() {
  std::string* _s = _internal_mutable_messagesecret();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.messageSecret)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_messagesecret() const {
  return _impl_.messagesecret_.Get();
}
inline void WebMessageInfo::_internal_set_messagesecret(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.messagesecret_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_messagesecret() {
  _impl_._has_bits_[0] |= 0x00000040u;
  return _impl_.messagesecret_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_messagesecret() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.messageSecret)
  if (!_internal_has_messagesecret()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000040u;
  auto* p = _impl_.messagesecret_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_messagesecret(std::string* messagesecret) {
  if (messagesecret != nullptr) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.messagesecret_.SetAllocated(messagesecret, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.messagesecret_.IsDefault()) {
    _impl_.messagesecret_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.messageSecret)
}

// optional .proto.KeepInChat keepInChat = 50;
inline bool WebMessageInfo::_internal_has_keepinchat() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.keepinchat_ != nullptr);
  return value;
}
inline bool WebMessageInfo::has_keepinchat() const {
  return _internal_has_keepinchat();
}
inline void WebMessageInfo::clear_keepinchat() {
  if (_impl_.keepinchat_ != nullptr) _impl_.keepinchat_->Clear();
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline const ::proto::KeepInChat& WebMessageInfo::_internal_keepinchat() const {
  const ::proto::KeepInChat* p = _impl_.keepinchat_;
  return p != nullptr ? *p : reinterpret_cast<const ::proto::KeepInChat&>(
      ::proto::_KeepInChat_default_instance_);
}
inline const ::proto::KeepInChat& WebMessageInfo::keepinchat() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.keepInChat)
  return _internal_keepinchat();
}
inline void WebMessageInfo::unsafe_arena_set_allocated_keepinchat(
    ::proto::KeepInChat* keepinchat) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.keepinchat_);
  }
  _impl_.keepinchat_ = keepinchat;
  if (keepinchat) {
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.WebMessageInfo.keepInChat)
}
inline ::proto::KeepInChat* WebMessageInfo::release_keepinchat() {
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::KeepInChat* temp = _impl_.keepinchat_;
  _impl_.keepinchat_ = 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 ::proto::KeepInChat* WebMessageInfo::unsafe_arena_release_keepinchat() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.keepInChat)
  _impl_._has_bits_[0] &= ~0x00040000u;
  ::proto::KeepInChat* temp = _impl_.keepinchat_;
  _impl_.keepinchat_ = nullptr;
  return temp;
}
inline ::proto::KeepInChat* WebMessageInfo::_internal_mutable_keepinchat() {
  _impl_._has_bits_[0] |= 0x00040000u;
  if (_impl_.keepinchat_ == nullptr) {
    auto* p = CreateMaybeMessage<::proto::KeepInChat>(GetArenaForAllocation());
    _impl_.keepinchat_ = p;
  }
  return _impl_.keepinchat_;
}
inline ::proto::KeepInChat* WebMessageInfo::mutable_keepinchat() {
  ::proto::KeepInChat* _msg = _internal_mutable_keepinchat();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.keepInChat)
  return _msg;
}
inline void WebMessageInfo::set_allocated_keepinchat(::proto::KeepInChat* keepinchat) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.keepinchat_;
  }
  if (keepinchat) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(keepinchat);
    if (message_arena != submessage_arena) {
      keepinchat = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keepinchat, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00040000u;
  } else {
    _impl_._has_bits_[0] &= ~0x00040000u;
  }
  _impl_.keepinchat_ = keepinchat;
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.keepInChat)
}

// optional string originalSelfAuthorUserJidString = 51;
inline bool WebMessageInfo::_internal_has_originalselfauthoruserjidstring() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool WebMessageInfo::has_originalselfauthoruserjidstring() const {
  return _internal_has_originalselfauthoruserjidstring();
}
inline void WebMessageInfo::clear_originalselfauthoruserjidstring() {
  _impl_.originalselfauthoruserjidstring_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline const std::string& WebMessageInfo::originalselfauthoruserjidstring() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.originalSelfAuthorUserJidString)
  return _internal_originalselfauthoruserjidstring();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void WebMessageInfo::set_originalselfauthoruserjidstring(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000080u;
 _impl_.originalselfauthoruserjidstring_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.originalSelfAuthorUserJidString)
}
inline std::string* WebMessageInfo::mutable_originalselfauthoruserjidstring() {
  std::string* _s = _internal_mutable_originalselfauthoruserjidstring();
  // @@protoc_insertion_point(field_mutable:proto.WebMessageInfo.originalSelfAuthorUserJidString)
  return _s;
}
inline const std::string& WebMessageInfo::_internal_originalselfauthoruserjidstring() const {
  return _impl_.originalselfauthoruserjidstring_.Get();
}
inline void WebMessageInfo::_internal_set_originalselfauthoruserjidstring(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.originalselfauthoruserjidstring_.Set(value, GetArenaForAllocation());
}
inline std::string* WebMessageInfo::_internal_mutable_originalselfauthoruserjidstring() {
  _impl_._has_bits_[0] |= 0x00000080u;
  return _impl_.originalselfauthoruserjidstring_.Mutable(GetArenaForAllocation());
}
inline std::string* WebMessageInfo::release_originalselfauthoruserjidstring() {
  // @@protoc_insertion_point(field_release:proto.WebMessageInfo.originalSelfAuthorUserJidString)
  if (!_internal_has_originalselfauthoruserjidstring()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000080u;
  auto* p = _impl_.originalselfauthoruserjidstring_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.originalselfauthoruserjidstring_.IsDefault()) {
    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void WebMessageInfo::set_allocated_originalselfauthoruserjidstring(std::string* originalselfauthoruserjidstring) {
  if (originalselfauthoruserjidstring != nullptr) {
    _impl_._has_bits_[0] |= 0x00000080u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000080u;
  }
  _impl_.originalselfauthoruserjidstring_.SetAllocated(originalselfauthoruserjidstring, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.originalselfauthoruserjidstring_.IsDefault()) {
    _impl_.originalselfauthoruserjidstring_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:proto.WebMessageInfo.originalSelfAuthorUserJidString)
}

// optional uint64 revokeMessageTimestamp = 52;
inline bool WebMessageInfo::_internal_has_revokemessagetimestamp() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool WebMessageInfo::has_revokemessagetimestamp() const {
  return _internal_has_revokemessagetimestamp();
}
inline void WebMessageInfo::clear_revokemessagetimestamp() {
  _impl_.revokemessagetimestamp_ = uint64_t{0u};
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline uint64_t WebMessageInfo::_internal_revokemessagetimestamp() const {
  return _impl_.revokemessagetimestamp_;
}
inline uint64_t WebMessageInfo::revokemessagetimestamp() const {
  // @@protoc_insertion_point(field_get:proto.WebMessageInfo.revokeMessageTimestamp)
  return _internal_revokemessagetimestamp();
}
inline void WebMessageInfo::_internal_set_revokemessagetimestamp(uint64_t value) {
  _impl_._has_bits_[1] |= 0x00000020u;
  _impl_.revokemessagetimestamp_ = value;
}
inline void WebMessageInfo::set_revokemessagetimestamp(uint64_t value) {
  _internal_set_revokemessagetimestamp(value);
  // @@protoc_insertion_point(field_set:proto.WebMessageInfo.revokeMessageTimestamp)
}

// -------------------------------------------------------------------

// WebNotificationsInfo

// optional uint64 timestamp = 2;
inline bool WebNotificationsInfo::_internal_has_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool WebNotificationsInfo::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void WebNotificationsInfo::clear_timestamp() {
  _impl_.timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t WebNotificationsInfo::_internal_timestamp() const {
  return _impl_.timestamp_;
}
inline uint64_t WebNotificationsInfo::timestamp() const {
  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.timestamp)
  return _internal_timestamp();
}
inline void WebNotificationsInfo::_internal_set_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.timestamp_ = value;
}
inline void WebNotificationsInfo::set_timestamp(uint64_t value) {
  _internal_set_timestamp(value);
  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.timestamp)
}

// optional uint32 unreadChats = 3;
inline bool WebNotificationsInfo::_internal_has_unreadchats() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool WebNotificationsInfo::has_unreadchats() const {
  return _internal_has_unreadchats();
}
inline void WebNotificationsInfo::clear_unreadchats() {
  _impl_.unreadchats_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t WebNotificationsInfo::_internal_unreadchats() const {
  return _impl_.unreadchats_;
}
inline uint32_t WebNotificationsInfo::unreadchats() const {
  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.unreadChats)
  return _internal_unreadchats();
}
inline void WebNotificationsInfo::_internal_set_unreadchats(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.unreadchats_ = value;
}
inline void WebNotificationsInfo::set_unreadchats(uint32_t value) {
  _internal_set_unreadchats(value);
  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.unreadChats)
}

// optional uint32 notifyMessageCount = 4;
inline bool WebNotificationsInfo::_internal_has_notifymessagecount() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool WebNotificationsInfo::has_notifymessagecount() const {
  return _internal_has_notifymessagecount();
}
inline void WebNotificationsInfo::clear_notifymessagecount() {
  _impl_.notifymessagecount_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t WebNotificationsInfo::_internal_notifymessagecount() const {
  return _impl_.notifymessagecount_;
}
inline uint32_t WebNotificationsInfo::notifymessagecount() const {
  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessageCount)
  return _internal_notifymessagecount();
}
inline void WebNotificationsInfo::_internal_set_notifymessagecount(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.notifymessagecount_ = value;
}
inline void WebNotificationsInfo::set_notifymessagecount(uint32_t value) {
  _internal_set_notifymessagecount(value);
  // @@protoc_insertion_point(field_set:proto.WebNotificationsInfo.notifyMessageCount)
}

// repeated .proto.WebMessageInfo notifyMessages = 5;
inline int WebNotificationsInfo::_internal_notifymessages_size() const {
  return _impl_.notifymessages_.size();
}
inline int WebNotificationsInfo::notifymessages_size() const {
  return _internal_notifymessages_size();
}
inline void WebNotificationsInfo::clear_notifymessages() {
  _impl_.notifymessages_.Clear();
}
inline ::proto::WebMessageInfo* WebNotificationsInfo::mutable_notifymessages(int index) {
  // @@protoc_insertion_point(field_mutable:proto.WebNotificationsInfo.notifyMessages)
  return _impl_.notifymessages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >*
WebNotificationsInfo::mutable_notifymessages() {
  // @@protoc_insertion_point(field_mutable_list:proto.WebNotificationsInfo.notifyMessages)
  return &_impl_.notifymessages_;
}
inline const ::proto::WebMessageInfo& WebNotificationsInfo::_internal_notifymessages(int index) const {
  return _impl_.notifymessages_.Get(index);
}
inline const ::proto::WebMessageInfo& WebNotificationsInfo::notifymessages(int index) const {
  // @@protoc_insertion_point(field_get:proto.WebNotificationsInfo.notifyMessages)
  return _internal_notifymessages(index);
}
inline ::proto::WebMessageInfo* WebNotificationsInfo::_internal_add_notifymessages() {
  return _impl_.notifymessages_.Add();
}
inline ::proto::WebMessageInfo* WebNotificationsInfo::add_notifymessages() {
  ::proto::WebMessageInfo* _add = _internal_add_notifymessages();
  // @@protoc_insertion_point(field_add:proto.WebNotificationsInfo.notifyMessages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto::WebMessageInfo >&
WebNotificationsInfo::notifymessages() const {
  // @@protoc_insertion_point(field_list:proto.WebNotificationsInfo.notifyMessages)
  return _impl_.notifymessages_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace proto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_AccountType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_AccountType>() {
  return ::proto::BizAccountLinkInfo_AccountType_descriptor();
}
template <> struct is_proto_enum< ::proto::BizAccountLinkInfo_HostStorageType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizAccountLinkInfo_HostStorageType>() {
  return ::proto::BizAccountLinkInfo_HostStorageType_descriptor();
}
template <> struct is_proto_enum< ::proto::BizIdentityInfo_ActualActorsType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_ActualActorsType>() {
  return ::proto::BizIdentityInfo_ActualActorsType_descriptor();
}
template <> struct is_proto_enum< ::proto::BizIdentityInfo_HostStorageType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_HostStorageType>() {
  return ::proto::BizIdentityInfo_HostStorageType_descriptor();
}
template <> struct is_proto_enum< ::proto::BizIdentityInfo_VerifiedLevelValue> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::BizIdentityInfo_VerifiedLevelValue>() {
  return ::proto::BizIdentityInfo_VerifiedLevelValue_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_DNSSource_DNSResolutionMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_DNSSource_DNSResolutionMethod>() {
  return ::proto::ClientPayload_DNSSource_DNSResolutionMethod_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_Platform> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_Platform>() {
  return ::proto::ClientPayload_UserAgent_Platform_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_UserAgent_ReleaseChannel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_UserAgent_ReleaseChannel>() {
  return ::proto::ClientPayload_UserAgent_ReleaseChannel_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_WebInfo_WebSubPlatform> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_WebInfo_WebSubPlatform>() {
  return ::proto::ClientPayload_WebInfo_WebSubPlatform_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_ConnectReason> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectReason>() {
  return ::proto::ClientPayload_ConnectReason_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_ConnectType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_ConnectType>() {
  return ::proto::ClientPayload_ConnectType_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_IOSAppExtension> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_IOSAppExtension>() {
  return ::proto::ClientPayload_IOSAppExtension_descriptor();
}
template <> struct is_proto_enum< ::proto::ClientPayload_Product> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ClientPayload_Product>() {
  return ::proto::ClientPayload_Product_descriptor();
}
template <> struct is_proto_enum< ::proto::ContextInfo_AdReplyInfo_MediaType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_AdReplyInfo_MediaType>() {
  return ::proto::ContextInfo_AdReplyInfo_MediaType_descriptor();
}
template <> struct is_proto_enum< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::ContextInfo_ExternalAdReplyInfo_MediaType>() {
  return ::proto::ContextInfo_ExternalAdReplyInfo_MediaType_descriptor();
}
template <> struct is_proto_enum< ::proto::Conversation_EndOfHistoryTransferType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Conversation_EndOfHistoryTransferType>() {
  return ::proto::Conversation_EndOfHistoryTransferType_descriptor();
}
template <> struct is_proto_enum< ::proto::DeviceProps_PlatformType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::DeviceProps_PlatformType>() {
  return ::proto::DeviceProps_PlatformType_descriptor();
}
template <> struct is_proto_enum< ::proto::DisappearingMode_Initiator> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::DisappearingMode_Initiator>() {
  return ::proto::DisappearingMode_Initiator_descriptor();
}
template <> struct is_proto_enum< ::proto::GroupParticipant_Rank> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::GroupParticipant_Rank>() {
  return ::proto::GroupParticipant_Rank_descriptor();
}
template <> struct is_proto_enum< ::proto::HistorySync_HistorySyncType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::HistorySync_HistorySyncType>() {
  return ::proto::HistorySync_HistorySyncType_descriptor();
}
template <> struct is_proto_enum< ::proto::MediaRetryNotification_ResultType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaRetryNotification_ResultType>() {
  return ::proto::MediaRetryNotification_ResultType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_Button_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_Button_Type>() {
  return ::proto::Message_ButtonsMessage_Button_Type_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ButtonsMessage_HeaderType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsMessage_HeaderType>() {
  return ::proto::Message_ButtonsMessage_HeaderType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ButtonsResponseMessage_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ButtonsResponseMessage_Type>() {
  return ::proto::Message_ButtonsResponseMessage_Type_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_FontType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_FontType>() {
  return ::proto::Message_ExtendedTextMessage_FontType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_InviteLinkGroupType>() {
  return ::proto::Message_ExtendedTextMessage_InviteLinkGroupType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ExtendedTextMessage_PreviewType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ExtendedTextMessage_PreviewType>() {
  return ::proto::Message_ExtendedTextMessage_PreviewType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_GroupInviteMessage_GroupType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_GroupInviteMessage_GroupType>() {
  return ::proto::Message_GroupInviteMessage_GroupType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType>() {
  return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_CalendarType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType>() {
  return ::proto::Message_HighlyStructuredMessage_HSMLocalizableParameter_HSMDateTime_HSMDateTimeComponent_DayOfWeekType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_HistorySyncNotification_HistorySyncType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_HistorySyncNotification_HistorySyncType>() {
  return ::proto::Message_HistorySyncNotification_HistorySyncType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_InteractiveMessage_ShopMessage_Surface> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InteractiveMessage_ShopMessage_Surface>() {
  return ::proto::Message_InteractiveMessage_ShopMessage_Surface_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_InvoiceMessage_AttachmentType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_InvoiceMessage_AttachmentType>() {
  return ::proto::Message_InvoiceMessage_AttachmentType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ListMessage_ListType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListMessage_ListType>() {
  return ::proto::Message_ListMessage_ListType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ListResponseMessage_ListType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ListResponseMessage_ListType>() {
  return ::proto::Message_ListResponseMessage_ListType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderStatus>() {
  return ::proto::Message_OrderMessage_OrderStatus_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_OrderMessage_OrderSurface> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_OrderMessage_OrderSurface>() {
  return ::proto::Message_OrderMessage_OrderSurface_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_PaymentInviteMessage_ServiceType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_PaymentInviteMessage_ServiceType>() {
  return ::proto::Message_PaymentInviteMessage_ServiceType_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_ProtocolMessage_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_ProtocolMessage_Type>() {
  return ::proto::Message_ProtocolMessage_Type_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_VideoMessage_Attribution> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_VideoMessage_Attribution>() {
  return ::proto::Message_VideoMessage_Attribution_descriptor();
}
template <> struct is_proto_enum< ::proto::Message_RmrSource> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::Message_RmrSource>() {
  return ::proto::Message_RmrSource_descriptor();
}
template <> struct is_proto_enum< ::proto::PastParticipant_LeaveReason> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::PastParticipant_LeaveReason>() {
  return ::proto::PastParticipant_LeaveReason_descriptor();
}
template <> struct is_proto_enum< ::proto::PaymentBackground_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentBackground_Type>() {
  return ::proto::PaymentBackground_Type_descriptor();
}
template <> struct is_proto_enum< ::proto::PaymentInfo_Currency> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Currency>() {
  return ::proto::PaymentInfo_Currency_descriptor();
}
template <> struct is_proto_enum< ::proto::PaymentInfo_Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_Status>() {
  return ::proto::PaymentInfo_Status_descriptor();
}
template <> struct is_proto_enum< ::proto::PaymentInfo_TxnStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::PaymentInfo_TxnStatus>() {
  return ::proto::PaymentInfo_TxnStatus_descriptor();
}
template <> struct is_proto_enum< ::proto::SyncdMutation_SyncdOperation> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::SyncdMutation_SyncdOperation>() {
  return ::proto::SyncdMutation_SyncdOperation_descriptor();
}
template <> struct is_proto_enum< ::proto::WebFeatures_Flag> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebFeatures_Flag>() {
  return ::proto::WebFeatures_Flag_descriptor();
}
template <> struct is_proto_enum< ::proto::WebMessageInfo_BizPrivacyStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_BizPrivacyStatus>() {
  return ::proto::WebMessageInfo_BizPrivacyStatus_descriptor();
}
template <> struct is_proto_enum< ::proto::WebMessageInfo_Status> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_Status>() {
  return ::proto::WebMessageInfo_Status_descriptor();
}
template <> struct is_proto_enum< ::proto::WebMessageInfo_StubType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::WebMessageInfo_StubType>() {
  return ::proto::WebMessageInfo_StubType_descriptor();
}
template <> struct is_proto_enum< ::proto::KeepType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::KeepType>() {
  return ::proto::KeepType_descriptor();
}
template <> struct is_proto_enum< ::proto::MediaVisibility> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::proto::MediaVisibility>() {
  return ::proto::MediaVisibility_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_pmsg_2eproto