chromium/out/Default/gen/google_apis/gcm/protocol/mcs.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_mcs_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_mcs_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include "google_apis/gcm/base/gcm_export.h"
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_mcs_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct GCM_EXPORT TableStruct_mcs_2eproto {};
namespace mcs_proto {
class AppData;
struct AppDataDefaultTypeInternal;
GCM_EXPORT extern AppDataDefaultTypeInternal _AppData_default_instance_;
class ClientEvent;
struct ClientEventDefaultTypeInternal;
GCM_EXPORT extern ClientEventDefaultTypeInternal _ClientEvent_default_instance_;
class Close;
struct CloseDefaultTypeInternal;
GCM_EXPORT extern CloseDefaultTypeInternal _Close_default_instance_;
class DataMessageStanza;
struct DataMessageStanzaDefaultTypeInternal;
GCM_EXPORT extern DataMessageStanzaDefaultTypeInternal _DataMessageStanza_default_instance_;
class ErrorInfo;
struct ErrorInfoDefaultTypeInternal;
GCM_EXPORT extern ErrorInfoDefaultTypeInternal _ErrorInfo_default_instance_;
class Extension;
struct ExtensionDefaultTypeInternal;
GCM_EXPORT extern ExtensionDefaultTypeInternal _Extension_default_instance_;
class HeartbeatAck;
struct HeartbeatAckDefaultTypeInternal;
GCM_EXPORT extern HeartbeatAckDefaultTypeInternal _HeartbeatAck_default_instance_;
class HeartbeatConfig;
struct HeartbeatConfigDefaultTypeInternal;
GCM_EXPORT extern HeartbeatConfigDefaultTypeInternal _HeartbeatConfig_default_instance_;
class HeartbeatPing;
struct HeartbeatPingDefaultTypeInternal;
GCM_EXPORT extern HeartbeatPingDefaultTypeInternal _HeartbeatPing_default_instance_;
class HeartbeatStat;
struct HeartbeatStatDefaultTypeInternal;
GCM_EXPORT extern HeartbeatStatDefaultTypeInternal _HeartbeatStat_default_instance_;
class IqStanza;
struct IqStanzaDefaultTypeInternal;
GCM_EXPORT extern IqStanzaDefaultTypeInternal _IqStanza_default_instance_;
class LoginRequest;
struct LoginRequestDefaultTypeInternal;
GCM_EXPORT extern LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
class LoginResponse;
struct LoginResponseDefaultTypeInternal;
GCM_EXPORT extern LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
class SelectiveAck;
struct SelectiveAckDefaultTypeInternal;
GCM_EXPORT extern SelectiveAckDefaultTypeInternal _SelectiveAck_default_instance_;
class Setting;
struct SettingDefaultTypeInternal;
GCM_EXPORT extern SettingDefaultTypeInternal _Setting_default_instance_;
class StreamAck;
struct StreamAckDefaultTypeInternal;
GCM_EXPORT extern StreamAckDefaultTypeInternal _StreamAck_default_instance_;
class StreamErrorStanza;
struct StreamErrorStanzaDefaultTypeInternal;
GCM_EXPORT extern StreamErrorStanzaDefaultTypeInternal _StreamErrorStanza_default_instance_;
}  // namespace mcs_proto
PROTOBUF_NAMESPACE_OPEN
template<> GCM_EXPORT ::mcs_proto::AppData* Arena::CreateMaybeMessage<::mcs_proto::AppData>(Arena*);
template<> GCM_EXPORT ::mcs_proto::ClientEvent* Arena::CreateMaybeMessage<::mcs_proto::ClientEvent>(Arena*);
template<> GCM_EXPORT ::mcs_proto::Close* Arena::CreateMaybeMessage<::mcs_proto::Close>(Arena*);
template<> GCM_EXPORT ::mcs_proto::DataMessageStanza* Arena::CreateMaybeMessage<::mcs_proto::DataMessageStanza>(Arena*);
template<> GCM_EXPORT ::mcs_proto::ErrorInfo* Arena::CreateMaybeMessage<::mcs_proto::ErrorInfo>(Arena*);
template<> GCM_EXPORT ::mcs_proto::Extension* Arena::CreateMaybeMessage<::mcs_proto::Extension>(Arena*);
template<> GCM_EXPORT ::mcs_proto::HeartbeatAck* Arena::CreateMaybeMessage<::mcs_proto::HeartbeatAck>(Arena*);
template<> GCM_EXPORT ::mcs_proto::HeartbeatConfig* Arena::CreateMaybeMessage<::mcs_proto::HeartbeatConfig>(Arena*);
template<> GCM_EXPORT ::mcs_proto::HeartbeatPing* Arena::CreateMaybeMessage<::mcs_proto::HeartbeatPing>(Arena*);
template<> GCM_EXPORT ::mcs_proto::HeartbeatStat* Arena::CreateMaybeMessage<::mcs_proto::HeartbeatStat>(Arena*);
template<> GCM_EXPORT ::mcs_proto::IqStanza* Arena::CreateMaybeMessage<::mcs_proto::IqStanza>(Arena*);
template<> GCM_EXPORT ::mcs_proto::LoginRequest* Arena::CreateMaybeMessage<::mcs_proto::LoginRequest>(Arena*);
template<> GCM_EXPORT ::mcs_proto::LoginResponse* Arena::CreateMaybeMessage<::mcs_proto::LoginResponse>(Arena*);
template<> GCM_EXPORT ::mcs_proto::SelectiveAck* Arena::CreateMaybeMessage<::mcs_proto::SelectiveAck>(Arena*);
template<> GCM_EXPORT ::mcs_proto::Setting* Arena::CreateMaybeMessage<::mcs_proto::Setting>(Arena*);
template<> GCM_EXPORT ::mcs_proto::StreamAck* Arena::CreateMaybeMessage<::mcs_proto::StreamAck>(Arena*);
template<> GCM_EXPORT ::mcs_proto::StreamErrorStanza* Arena::CreateMaybeMessage<::mcs_proto::StreamErrorStanza>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace mcs_proto {

enum ClientEvent_Type : int {};
GCM_EXPORT bool ClientEvent_Type_IsValid(int value);
constexpr ClientEvent_Type ClientEvent_Type_Type_MIN =;
constexpr ClientEvent_Type ClientEvent_Type_Type_MAX =;
constexpr int ClientEvent_Type_Type_ARRAYSIZE =;

const std::string& ClientEvent_Type_Name(ClientEvent_Type value);
template<typename T>
inline const std::string& ClientEvent_Type_Name(T enum_t_value) {}
bool ClientEvent_Type_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientEvent_Type* value);
enum LoginRequest_AuthService : int {};
GCM_EXPORT bool LoginRequest_AuthService_IsValid(int value);
constexpr LoginRequest_AuthService LoginRequest_AuthService_AuthService_MIN =;
constexpr LoginRequest_AuthService LoginRequest_AuthService_AuthService_MAX =;
constexpr int LoginRequest_AuthService_AuthService_ARRAYSIZE =;

const std::string& LoginRequest_AuthService_Name(LoginRequest_AuthService value);
template<typename T>
inline const std::string& LoginRequest_AuthService_Name(T enum_t_value) {}
bool LoginRequest_AuthService_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginRequest_AuthService* value);
enum IqStanza_IqType : int {};
GCM_EXPORT bool IqStanza_IqType_IsValid(int value);
constexpr IqStanza_IqType IqStanza_IqType_IqType_MIN =;
constexpr IqStanza_IqType IqStanza_IqType_IqType_MAX =;
constexpr int IqStanza_IqType_IqType_ARRAYSIZE =;

const std::string& IqStanza_IqType_Name(IqStanza_IqType value);
template<typename T>
inline const std::string& IqStanza_IqType_Name(T enum_t_value) {}
bool IqStanza_IqType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IqStanza_IqType* value);
// ===================================================================

class GCM_EXPORT HeartbeatPing final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.HeartbeatPing) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT HeartbeatAck final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.HeartbeatAck) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT ErrorInfo final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.ErrorInfo) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT Setting final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.Setting) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT HeartbeatStat final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.HeartbeatStat) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT HeartbeatConfig final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.HeartbeatConfig) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT ClientEvent final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.ClientEvent) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT LoginRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.LoginRequest) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT LoginResponse final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.LoginResponse) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT StreamErrorStanza final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.StreamErrorStanza) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT Close final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.Close) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT Extension final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.Extension) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT IqStanza final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.IqStanza) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT AppData final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.AppData) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT DataMessageStanza final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.DataMessageStanza) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT StreamAck final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.StreamAck) */ {};
// -------------------------------------------------------------------

class GCM_EXPORT SelectiveAck final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:mcs_proto.SelectiveAck) */ {};
// ===================================================================


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

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

// optional int32 stream_id = 1;
inline bool HeartbeatPing::_internal_has_stream_id() const {}
inline bool HeartbeatPing::has_stream_id() const {}
inline void HeartbeatPing::clear_stream_id() {}
inline int32_t HeartbeatPing::_internal_stream_id() const {}
inline int32_t HeartbeatPing::stream_id() const {}
inline void HeartbeatPing::_internal_set_stream_id(int32_t value) {}
inline void HeartbeatPing::set_stream_id(int32_t value) {}

// optional int32 last_stream_id_received = 2;
inline bool HeartbeatPing::_internal_has_last_stream_id_received() const {}
inline bool HeartbeatPing::has_last_stream_id_received() const {}
inline void HeartbeatPing::clear_last_stream_id_received() {}
inline int32_t HeartbeatPing::_internal_last_stream_id_received() const {}
inline int32_t HeartbeatPing::last_stream_id_received() const {}
inline void HeartbeatPing::_internal_set_last_stream_id_received(int32_t value) {}
inline void HeartbeatPing::set_last_stream_id_received(int32_t value) {}

// optional int64 status = 3;
inline bool HeartbeatPing::_internal_has_status() const {}
inline bool HeartbeatPing::has_status() const {}
inline void HeartbeatPing::clear_status() {}
inline int64_t HeartbeatPing::_internal_status() const {}
inline int64_t HeartbeatPing::status() const {}
inline void HeartbeatPing::_internal_set_status(int64_t value) {}
inline void HeartbeatPing::set_status(int64_t value) {}

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

// HeartbeatAck

// optional int32 stream_id = 1;
inline bool HeartbeatAck::_internal_has_stream_id() const {}
inline bool HeartbeatAck::has_stream_id() const {}
inline void HeartbeatAck::clear_stream_id() {}
inline int32_t HeartbeatAck::_internal_stream_id() const {}
inline int32_t HeartbeatAck::stream_id() const {}
inline void HeartbeatAck::_internal_set_stream_id(int32_t value) {}
inline void HeartbeatAck::set_stream_id(int32_t value) {}

// optional int32 last_stream_id_received = 2;
inline bool HeartbeatAck::_internal_has_last_stream_id_received() const {}
inline bool HeartbeatAck::has_last_stream_id_received() const {}
inline void HeartbeatAck::clear_last_stream_id_received() {}
inline int32_t HeartbeatAck::_internal_last_stream_id_received() const {}
inline int32_t HeartbeatAck::last_stream_id_received() const {}
inline void HeartbeatAck::_internal_set_last_stream_id_received(int32_t value) {}
inline void HeartbeatAck::set_last_stream_id_received(int32_t value) {}

// optional int64 status = 3;
inline bool HeartbeatAck::_internal_has_status() const {}
inline bool HeartbeatAck::has_status() const {}
inline void HeartbeatAck::clear_status() {}
inline int64_t HeartbeatAck::_internal_status() const {}
inline int64_t HeartbeatAck::status() const {}
inline void HeartbeatAck::_internal_set_status(int64_t value) {}
inline void HeartbeatAck::set_status(int64_t value) {}

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

// ErrorInfo

// required int32 code = 1;
inline bool ErrorInfo::_internal_has_code() const {}
inline bool ErrorInfo::has_code() const {}
inline void ErrorInfo::clear_code() {}
inline int32_t ErrorInfo::_internal_code() const {}
inline int32_t ErrorInfo::code() const {}
inline void ErrorInfo::_internal_set_code(int32_t value) {}
inline void ErrorInfo::set_code(int32_t value) {}

// optional string message = 2;
inline bool ErrorInfo::_internal_has_message() const {}
inline bool ErrorInfo::has_message() const {}
inline void ErrorInfo::clear_message() {}
inline const std::string& ErrorInfo::message() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ErrorInfo::set_message(ArgT0&& arg0, ArgT... args) {}
inline std::string* ErrorInfo::mutable_message() {}
inline const std::string& ErrorInfo::_internal_message() const {}
inline void ErrorInfo::_internal_set_message(const std::string& value) {}
inline std::string* ErrorInfo::_internal_mutable_message() {}
inline std::string* ErrorInfo::release_message() {}
inline void ErrorInfo::set_allocated_message(std::string* message) {}

// optional string type = 3;
inline bool ErrorInfo::_internal_has_type() const {}
inline bool ErrorInfo::has_type() const {}
inline void ErrorInfo::clear_type() {}
inline const std::string& ErrorInfo::type() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ErrorInfo::set_type(ArgT0&& arg0, ArgT... args) {}
inline std::string* ErrorInfo::mutable_type() {}
inline const std::string& ErrorInfo::_internal_type() const {}
inline void ErrorInfo::_internal_set_type(const std::string& value) {}
inline std::string* ErrorInfo::_internal_mutable_type() {}
inline std::string* ErrorInfo::release_type() {}
inline void ErrorInfo::set_allocated_type(std::string* type) {}

// optional .mcs_proto.Extension extension = 4;
inline bool ErrorInfo::_internal_has_extension() const {}
inline bool ErrorInfo::has_extension() const {}
inline void ErrorInfo::clear_extension() {}
inline const ::mcs_proto::Extension& ErrorInfo::_internal_extension() const {}
inline const ::mcs_proto::Extension& ErrorInfo::extension() const {}
inline void ErrorInfo::unsafe_arena_set_allocated_extension(
::mcs_proto::Extension* extension) {}
inline ::mcs_proto::Extension* ErrorInfo::release_extension() {}
inline ::mcs_proto::Extension* ErrorInfo::unsafe_arena_release_extension() {}
inline ::mcs_proto::Extension* ErrorInfo::_internal_mutable_extension() {}
inline ::mcs_proto::Extension* ErrorInfo::mutable_extension() {}
inline void ErrorInfo::set_allocated_extension(::mcs_proto::Extension* extension) {}

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

// Setting

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

// required string value = 2;
inline bool Setting::_internal_has_value() const {}
inline bool Setting::has_value() const {}
inline void Setting::clear_value() {}
inline const std::string& Setting::value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Setting::set_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* Setting::mutable_value() {}
inline const std::string& Setting::_internal_value() const {}
inline void Setting::_internal_set_value(const std::string& value) {}
inline std::string* Setting::_internal_mutable_value() {}
inline std::string* Setting::release_value() {}
inline void Setting::set_allocated_value(std::string* value) {}

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

// HeartbeatStat

// required string ip = 1;
inline bool HeartbeatStat::_internal_has_ip() const {}
inline bool HeartbeatStat::has_ip() const {}
inline void HeartbeatStat::clear_ip() {}
inline const std::string& HeartbeatStat::ip() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeartbeatStat::set_ip(ArgT0&& arg0, ArgT... args) {}
inline std::string* HeartbeatStat::mutable_ip() {}
inline const std::string& HeartbeatStat::_internal_ip() const {}
inline void HeartbeatStat::_internal_set_ip(const std::string& value) {}
inline std::string* HeartbeatStat::_internal_mutable_ip() {}
inline std::string* HeartbeatStat::release_ip() {}
inline void HeartbeatStat::set_allocated_ip(std::string* ip) {}

// required bool timeout = 2;
inline bool HeartbeatStat::_internal_has_timeout() const {}
inline bool HeartbeatStat::has_timeout() const {}
inline void HeartbeatStat::clear_timeout() {}
inline bool HeartbeatStat::_internal_timeout() const {}
inline bool HeartbeatStat::timeout() const {}
inline void HeartbeatStat::_internal_set_timeout(bool value) {}
inline void HeartbeatStat::set_timeout(bool value) {}

// required int32 interval_ms = 3;
inline bool HeartbeatStat::_internal_has_interval_ms() const {}
inline bool HeartbeatStat::has_interval_ms() const {}
inline void HeartbeatStat::clear_interval_ms() {}
inline int32_t HeartbeatStat::_internal_interval_ms() const {}
inline int32_t HeartbeatStat::interval_ms() const {}
inline void HeartbeatStat::_internal_set_interval_ms(int32_t value) {}
inline void HeartbeatStat::set_interval_ms(int32_t value) {}

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

// HeartbeatConfig

// optional bool upload_stat = 1;
inline bool HeartbeatConfig::_internal_has_upload_stat() const {}
inline bool HeartbeatConfig::has_upload_stat() const {}
inline void HeartbeatConfig::clear_upload_stat() {}
inline bool HeartbeatConfig::_internal_upload_stat() const {}
inline bool HeartbeatConfig::upload_stat() const {}
inline void HeartbeatConfig::_internal_set_upload_stat(bool value) {}
inline void HeartbeatConfig::set_upload_stat(bool value) {}

// optional string ip = 2;
inline bool HeartbeatConfig::_internal_has_ip() const {}
inline bool HeartbeatConfig::has_ip() const {}
inline void HeartbeatConfig::clear_ip() {}
inline const std::string& HeartbeatConfig::ip() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void HeartbeatConfig::set_ip(ArgT0&& arg0, ArgT... args) {}
inline std::string* HeartbeatConfig::mutable_ip() {}
inline const std::string& HeartbeatConfig::_internal_ip() const {}
inline void HeartbeatConfig::_internal_set_ip(const std::string& value) {}
inline std::string* HeartbeatConfig::_internal_mutable_ip() {}
inline std::string* HeartbeatConfig::release_ip() {}
inline void HeartbeatConfig::set_allocated_ip(std::string* ip) {}

// optional int32 interval_ms = 3;
inline bool HeartbeatConfig::_internal_has_interval_ms() const {}
inline bool HeartbeatConfig::has_interval_ms() const {}
inline void HeartbeatConfig::clear_interval_ms() {}
inline int32_t HeartbeatConfig::_internal_interval_ms() const {}
inline int32_t HeartbeatConfig::interval_ms() const {}
inline void HeartbeatConfig::_internal_set_interval_ms(int32_t value) {}
inline void HeartbeatConfig::set_interval_ms(int32_t value) {}

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

// ClientEvent

// optional .mcs_proto.ClientEvent.Type type = 1;
inline bool ClientEvent::_internal_has_type() const {}
inline bool ClientEvent::has_type() const {}
inline void ClientEvent::clear_type() {}
inline ::mcs_proto::ClientEvent_Type ClientEvent::_internal_type() const {}
inline ::mcs_proto::ClientEvent_Type ClientEvent::type() const {}
inline void ClientEvent::_internal_set_type(::mcs_proto::ClientEvent_Type value) {}
inline void ClientEvent::set_type(::mcs_proto::ClientEvent_Type value) {}

// optional uint32 number_discarded_events = 100;
inline bool ClientEvent::_internal_has_number_discarded_events() const {}
inline bool ClientEvent::has_number_discarded_events() const {}
inline void ClientEvent::clear_number_discarded_events() {}
inline uint32_t ClientEvent::_internal_number_discarded_events() const {}
inline uint32_t ClientEvent::number_discarded_events() const {}
inline void ClientEvent::_internal_set_number_discarded_events(uint32_t value) {}
inline void ClientEvent::set_number_discarded_events(uint32_t value) {}

// optional int32 network_type = 200;
inline bool ClientEvent::_internal_has_network_type() const {}
inline bool ClientEvent::has_network_type() const {}
inline void ClientEvent::clear_network_type() {}
inline int32_t ClientEvent::_internal_network_type() const {}
inline int32_t ClientEvent::network_type() const {}
inline void ClientEvent::_internal_set_network_type(int32_t value) {}
inline void ClientEvent::set_network_type(int32_t value) {}

// optional uint64 time_connection_started_ms = 202;
inline bool ClientEvent::_internal_has_time_connection_started_ms() const {}
inline bool ClientEvent::has_time_connection_started_ms() const {}
inline void ClientEvent::clear_time_connection_started_ms() {}
inline uint64_t ClientEvent::_internal_time_connection_started_ms() const {}
inline uint64_t ClientEvent::time_connection_started_ms() const {}
inline void ClientEvent::_internal_set_time_connection_started_ms(uint64_t value) {}
inline void ClientEvent::set_time_connection_started_ms(uint64_t value) {}

// optional uint64 time_connection_ended_ms = 203;
inline bool ClientEvent::_internal_has_time_connection_ended_ms() const {}
inline bool ClientEvent::has_time_connection_ended_ms() const {}
inline void ClientEvent::clear_time_connection_ended_ms() {}
inline uint64_t ClientEvent::_internal_time_connection_ended_ms() const {}
inline uint64_t ClientEvent::time_connection_ended_ms() const {}
inline void ClientEvent::_internal_set_time_connection_ended_ms(uint64_t value) {}
inline void ClientEvent::set_time_connection_ended_ms(uint64_t value) {}

// optional int32 error_code = 204;
inline bool ClientEvent::_internal_has_error_code() const {}
inline bool ClientEvent::has_error_code() const {}
inline void ClientEvent::clear_error_code() {}
inline int32_t ClientEvent::_internal_error_code() const {}
inline int32_t ClientEvent::error_code() const {}
inline void ClientEvent::_internal_set_error_code(int32_t value) {}
inline void ClientEvent::set_error_code(int32_t value) {}

// optional uint64 time_connection_established_ms = 300;
inline bool ClientEvent::_internal_has_time_connection_established_ms() const {}
inline bool ClientEvent::has_time_connection_established_ms() const {}
inline void ClientEvent::clear_time_connection_established_ms() {}
inline uint64_t ClientEvent::_internal_time_connection_established_ms() const {}
inline uint64_t ClientEvent::time_connection_established_ms() const {}
inline void ClientEvent::_internal_set_time_connection_established_ms(uint64_t value) {}
inline void ClientEvent::set_time_connection_established_ms(uint64_t value) {}

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

// LoginRequest

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

// required string domain = 2;
inline bool LoginRequest::_internal_has_domain() const {}
inline bool LoginRequest::has_domain() const {}
inline void LoginRequest::clear_domain() {}
inline const std::string& LoginRequest::domain() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginRequest::set_domain(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginRequest::mutable_domain() {}
inline const std::string& LoginRequest::_internal_domain() const {}
inline void LoginRequest::_internal_set_domain(const std::string& value) {}
inline std::string* LoginRequest::_internal_mutable_domain() {}
inline std::string* LoginRequest::release_domain() {}
inline void LoginRequest::set_allocated_domain(std::string* domain) {}

// required string user = 3;
inline bool LoginRequest::_internal_has_user() const {}
inline bool LoginRequest::has_user() const {}
inline void LoginRequest::clear_user() {}
inline const std::string& LoginRequest::user() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginRequest::set_user(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginRequest::mutable_user() {}
inline const std::string& LoginRequest::_internal_user() const {}
inline void LoginRequest::_internal_set_user(const std::string& value) {}
inline std::string* LoginRequest::_internal_mutable_user() {}
inline std::string* LoginRequest::release_user() {}
inline void LoginRequest::set_allocated_user(std::string* user) {}

// required string resource = 4;
inline bool LoginRequest::_internal_has_resource() const {}
inline bool LoginRequest::has_resource() const {}
inline void LoginRequest::clear_resource() {}
inline const std::string& LoginRequest::resource() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginRequest::set_resource(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginRequest::mutable_resource() {}
inline const std::string& LoginRequest::_internal_resource() const {}
inline void LoginRequest::_internal_set_resource(const std::string& value) {}
inline std::string* LoginRequest::_internal_mutable_resource() {}
inline std::string* LoginRequest::release_resource() {}
inline void LoginRequest::set_allocated_resource(std::string* resource) {}

// required string auth_token = 5;
inline bool LoginRequest::_internal_has_auth_token() const {}
inline bool LoginRequest::has_auth_token() const {}
inline void LoginRequest::clear_auth_token() {}
inline const std::string& LoginRequest::auth_token() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginRequest::set_auth_token(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginRequest::mutable_auth_token() {}
inline const std::string& LoginRequest::_internal_auth_token() const {}
inline void LoginRequest::_internal_set_auth_token(const std::string& value) {}
inline std::string* LoginRequest::_internal_mutable_auth_token() {}
inline std::string* LoginRequest::release_auth_token() {}
inline void LoginRequest::set_allocated_auth_token(std::string* auth_token) {}

// optional string device_id = 6;
inline bool LoginRequest::_internal_has_device_id() const {}
inline bool LoginRequest::has_device_id() const {}
inline void LoginRequest::clear_device_id() {}
inline const std::string& LoginRequest::device_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginRequest::set_device_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginRequest::mutable_device_id() {}
inline const std::string& LoginRequest::_internal_device_id() const {}
inline void LoginRequest::_internal_set_device_id(const std::string& value) {}
inline std::string* LoginRequest::_internal_mutable_device_id() {}
inline std::string* LoginRequest::release_device_id() {}
inline void LoginRequest::set_allocated_device_id(std::string* device_id) {}

// optional int64 last_rmq_id = 7;
inline bool LoginRequest::_internal_has_last_rmq_id() const {}
inline bool LoginRequest::has_last_rmq_id() const {}
inline void LoginRequest::clear_last_rmq_id() {}
inline int64_t LoginRequest::_internal_last_rmq_id() const {}
inline int64_t LoginRequest::last_rmq_id() const {}
inline void LoginRequest::_internal_set_last_rmq_id(int64_t value) {}
inline void LoginRequest::set_last_rmq_id(int64_t value) {}

// repeated .mcs_proto.Setting setting = 8;
inline int LoginRequest::_internal_setting_size() const {}
inline int LoginRequest::setting_size() const {}
inline void LoginRequest::clear_setting() {}
inline ::mcs_proto::Setting* LoginRequest::mutable_setting(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::Setting >*
LoginRequest::mutable_setting() {}
inline const ::mcs_proto::Setting& LoginRequest::_internal_setting(int index) const {}
inline const ::mcs_proto::Setting& LoginRequest::setting(int index) const {}
inline ::mcs_proto::Setting* LoginRequest::_internal_add_setting() {}
inline ::mcs_proto::Setting* LoginRequest::add_setting() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::Setting >&
LoginRequest::setting() const {}

// repeated string received_persistent_id = 10;
inline int LoginRequest::_internal_received_persistent_id_size() const {}
inline int LoginRequest::received_persistent_id_size() const {}
inline void LoginRequest::clear_received_persistent_id() {}
inline std::string* LoginRequest::add_received_persistent_id() {}
inline const std::string& LoginRequest::_internal_received_persistent_id(int index) const {}
inline const std::string& LoginRequest::received_persistent_id(int index) const {}
inline std::string* LoginRequest::mutable_received_persistent_id(int index) {}
inline void LoginRequest::set_received_persistent_id(int index, const std::string& value) {}
inline void LoginRequest::set_received_persistent_id(int index, std::string&& value) {}
inline void LoginRequest::set_received_persistent_id(int index, const char* value) {}
inline void LoginRequest::set_received_persistent_id(int index, const char* value, size_t size) {}
inline std::string* LoginRequest::_internal_add_received_persistent_id() {}
inline void LoginRequest::add_received_persistent_id(const std::string& value) {}
inline void LoginRequest::add_received_persistent_id(std::string&& value) {}
inline void LoginRequest::add_received_persistent_id(const char* value) {}
inline void LoginRequest::add_received_persistent_id(const char* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
LoginRequest::received_persistent_id() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
LoginRequest::mutable_received_persistent_id() {}

// optional bool adaptive_heartbeat = 12;
inline bool LoginRequest::_internal_has_adaptive_heartbeat() const {}
inline bool LoginRequest::has_adaptive_heartbeat() const {}
inline void LoginRequest::clear_adaptive_heartbeat() {}
inline bool LoginRequest::_internal_adaptive_heartbeat() const {}
inline bool LoginRequest::adaptive_heartbeat() const {}
inline void LoginRequest::_internal_set_adaptive_heartbeat(bool value) {}
inline void LoginRequest::set_adaptive_heartbeat(bool value) {}

// optional .mcs_proto.HeartbeatStat heartbeat_stat = 13;
inline bool LoginRequest::_internal_has_heartbeat_stat() const {}
inline bool LoginRequest::has_heartbeat_stat() const {}
inline void LoginRequest::clear_heartbeat_stat() {}
inline const ::mcs_proto::HeartbeatStat& LoginRequest::_internal_heartbeat_stat() const {}
inline const ::mcs_proto::HeartbeatStat& LoginRequest::heartbeat_stat() const {}
inline void LoginRequest::unsafe_arena_set_allocated_heartbeat_stat(
::mcs_proto::HeartbeatStat* heartbeat_stat) {}
inline ::mcs_proto::HeartbeatStat* LoginRequest::release_heartbeat_stat() {}
inline ::mcs_proto::HeartbeatStat* LoginRequest::unsafe_arena_release_heartbeat_stat() {}
inline ::mcs_proto::HeartbeatStat* LoginRequest::_internal_mutable_heartbeat_stat() {}
inline ::mcs_proto::HeartbeatStat* LoginRequest::mutable_heartbeat_stat() {}
inline void LoginRequest::set_allocated_heartbeat_stat(::mcs_proto::HeartbeatStat* heartbeat_stat) {}

// optional bool use_rmq2 = 14;
inline bool LoginRequest::_internal_has_use_rmq2() const {}
inline bool LoginRequest::has_use_rmq2() const {}
inline void LoginRequest::clear_use_rmq2() {}
inline bool LoginRequest::_internal_use_rmq2() const {}
inline bool LoginRequest::use_rmq2() const {}
inline void LoginRequest::_internal_set_use_rmq2(bool value) {}
inline void LoginRequest::set_use_rmq2(bool value) {}

// optional int64 account_id = 15;
inline bool LoginRequest::_internal_has_account_id() const {}
inline bool LoginRequest::has_account_id() const {}
inline void LoginRequest::clear_account_id() {}
inline int64_t LoginRequest::_internal_account_id() const {}
inline int64_t LoginRequest::account_id() const {}
inline void LoginRequest::_internal_set_account_id(int64_t value) {}
inline void LoginRequest::set_account_id(int64_t value) {}

// optional .mcs_proto.LoginRequest.AuthService auth_service = 16;
inline bool LoginRequest::_internal_has_auth_service() const {}
inline bool LoginRequest::has_auth_service() const {}
inline void LoginRequest::clear_auth_service() {}
inline ::mcs_proto::LoginRequest_AuthService LoginRequest::_internal_auth_service() const {}
inline ::mcs_proto::LoginRequest_AuthService LoginRequest::auth_service() const {}
inline void LoginRequest::_internal_set_auth_service(::mcs_proto::LoginRequest_AuthService value) {}
inline void LoginRequest::set_auth_service(::mcs_proto::LoginRequest_AuthService value) {}

// optional int32 network_type = 17;
inline bool LoginRequest::_internal_has_network_type() const {}
inline bool LoginRequest::has_network_type() const {}
inline void LoginRequest::clear_network_type() {}
inline int32_t LoginRequest::_internal_network_type() const {}
inline int32_t LoginRequest::network_type() const {}
inline void LoginRequest::_internal_set_network_type(int32_t value) {}
inline void LoginRequest::set_network_type(int32_t value) {}

// optional int64 status = 18;
inline bool LoginRequest::_internal_has_status() const {}
inline bool LoginRequest::has_status() const {}
inline void LoginRequest::clear_status() {}
inline int64_t LoginRequest::_internal_status() const {}
inline int64_t LoginRequest::status() const {}
inline void LoginRequest::_internal_set_status(int64_t value) {}
inline void LoginRequest::set_status(int64_t value) {}

// repeated .mcs_proto.ClientEvent client_event = 22;
inline int LoginRequest::_internal_client_event_size() const {}
inline int LoginRequest::client_event_size() const {}
inline void LoginRequest::clear_client_event() {}
inline ::mcs_proto::ClientEvent* LoginRequest::mutable_client_event(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::ClientEvent >*
LoginRequest::mutable_client_event() {}
inline const ::mcs_proto::ClientEvent& LoginRequest::_internal_client_event(int index) const {}
inline const ::mcs_proto::ClientEvent& LoginRequest::client_event(int index) const {}
inline ::mcs_proto::ClientEvent* LoginRequest::_internal_add_client_event() {}
inline ::mcs_proto::ClientEvent* LoginRequest::add_client_event() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::ClientEvent >&
LoginRequest::client_event() const {}

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

// LoginResponse

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

// optional string jid = 2;
inline bool LoginResponse::_internal_has_jid() const {}
inline bool LoginResponse::has_jid() const {}
inline void LoginResponse::clear_jid() {}
inline const std::string& LoginResponse::jid() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void LoginResponse::set_jid(ArgT0&& arg0, ArgT... args) {}
inline std::string* LoginResponse::mutable_jid() {}
inline const std::string& LoginResponse::_internal_jid() const {}
inline void LoginResponse::_internal_set_jid(const std::string& value) {}
inline std::string* LoginResponse::_internal_mutable_jid() {}
inline std::string* LoginResponse::release_jid() {}
inline void LoginResponse::set_allocated_jid(std::string* jid) {}

// optional .mcs_proto.ErrorInfo error = 3;
inline bool LoginResponse::_internal_has_error() const {}
inline bool LoginResponse::has_error() const {}
inline void LoginResponse::clear_error() {}
inline const ::mcs_proto::ErrorInfo& LoginResponse::_internal_error() const {}
inline const ::mcs_proto::ErrorInfo& LoginResponse::error() const {}
inline void LoginResponse::unsafe_arena_set_allocated_error(
::mcs_proto::ErrorInfo* error) {}
inline ::mcs_proto::ErrorInfo* LoginResponse::release_error() {}
inline ::mcs_proto::ErrorInfo* LoginResponse::unsafe_arena_release_error() {}
inline ::mcs_proto::ErrorInfo* LoginResponse::_internal_mutable_error() {}
inline ::mcs_proto::ErrorInfo* LoginResponse::mutable_error() {}
inline void LoginResponse::set_allocated_error(::mcs_proto::ErrorInfo* error) {}

// repeated .mcs_proto.Setting setting = 4;
inline int LoginResponse::_internal_setting_size() const {}
inline int LoginResponse::setting_size() const {}
inline void LoginResponse::clear_setting() {}
inline ::mcs_proto::Setting* LoginResponse::mutable_setting(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::Setting >*
LoginResponse::mutable_setting() {}
inline const ::mcs_proto::Setting& LoginResponse::_internal_setting(int index) const {}
inline const ::mcs_proto::Setting& LoginResponse::setting(int index) const {}
inline ::mcs_proto::Setting* LoginResponse::_internal_add_setting() {}
inline ::mcs_proto::Setting* LoginResponse::add_setting() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::Setting >&
LoginResponse::setting() const {}

// optional int32 stream_id = 5;
inline bool LoginResponse::_internal_has_stream_id() const {}
inline bool LoginResponse::has_stream_id() const {}
inline void LoginResponse::clear_stream_id() {}
inline int32_t LoginResponse::_internal_stream_id() const {}
inline int32_t LoginResponse::stream_id() const {}
inline void LoginResponse::_internal_set_stream_id(int32_t value) {}
inline void LoginResponse::set_stream_id(int32_t value) {}

// optional int32 last_stream_id_received = 6;
inline bool LoginResponse::_internal_has_last_stream_id_received() const {}
inline bool LoginResponse::has_last_stream_id_received() const {}
inline void LoginResponse::clear_last_stream_id_received() {}
inline int32_t LoginResponse::_internal_last_stream_id_received() const {}
inline int32_t LoginResponse::last_stream_id_received() const {}
inline void LoginResponse::_internal_set_last_stream_id_received(int32_t value) {}
inline void LoginResponse::set_last_stream_id_received(int32_t value) {}

// optional .mcs_proto.HeartbeatConfig heartbeat_config = 7;
inline bool LoginResponse::_internal_has_heartbeat_config() const {}
inline bool LoginResponse::has_heartbeat_config() const {}
inline void LoginResponse::clear_heartbeat_config() {}
inline const ::mcs_proto::HeartbeatConfig& LoginResponse::_internal_heartbeat_config() const {}
inline const ::mcs_proto::HeartbeatConfig& LoginResponse::heartbeat_config() const {}
inline void LoginResponse::unsafe_arena_set_allocated_heartbeat_config(
::mcs_proto::HeartbeatConfig* heartbeat_config) {}
inline ::mcs_proto::HeartbeatConfig* LoginResponse::release_heartbeat_config() {}
inline ::mcs_proto::HeartbeatConfig* LoginResponse::unsafe_arena_release_heartbeat_config() {}
inline ::mcs_proto::HeartbeatConfig* LoginResponse::_internal_mutable_heartbeat_config() {}
inline ::mcs_proto::HeartbeatConfig* LoginResponse::mutable_heartbeat_config() {}
inline void LoginResponse::set_allocated_heartbeat_config(::mcs_proto::HeartbeatConfig* heartbeat_config) {}

// optional int64 server_timestamp = 8;
inline bool LoginResponse::_internal_has_server_timestamp() const {}
inline bool LoginResponse::has_server_timestamp() const {}
inline void LoginResponse::clear_server_timestamp() {}
inline int64_t LoginResponse::_internal_server_timestamp() const {}
inline int64_t LoginResponse::server_timestamp() const {}
inline void LoginResponse::_internal_set_server_timestamp(int64_t value) {}
inline void LoginResponse::set_server_timestamp(int64_t value) {}

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

// StreamErrorStanza

// required string type = 1;
inline bool StreamErrorStanza::_internal_has_type() const {}
inline bool StreamErrorStanza::has_type() const {}
inline void StreamErrorStanza::clear_type() {}
inline const std::string& StreamErrorStanza::type() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void StreamErrorStanza::set_type(ArgT0&& arg0, ArgT... args) {}
inline std::string* StreamErrorStanza::mutable_type() {}
inline const std::string& StreamErrorStanza::_internal_type() const {}
inline void StreamErrorStanza::_internal_set_type(const std::string& value) {}
inline std::string* StreamErrorStanza::_internal_mutable_type() {}
inline std::string* StreamErrorStanza::release_type() {}
inline void StreamErrorStanza::set_allocated_type(std::string* type) {}

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

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

// Close

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

// Extension

// required int32 id = 1;
inline bool Extension::_internal_has_id() const {}
inline bool Extension::has_id() const {}
inline void Extension::clear_id() {}
inline int32_t Extension::_internal_id() const {}
inline int32_t Extension::id() const {}
inline void Extension::_internal_set_id(int32_t value) {}
inline void Extension::set_id(int32_t value) {}

// required bytes data = 2;
inline bool Extension::_internal_has_data() const {}
inline bool Extension::has_data() const {}
inline void Extension::clear_data() {}
inline const std::string& Extension::data() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Extension::set_data(ArgT0&& arg0, ArgT... args) {}
inline std::string* Extension::mutable_data() {}
inline const std::string& Extension::_internal_data() const {}
inline void Extension::_internal_set_data(const std::string& value) {}
inline std::string* Extension::_internal_mutable_data() {}
inline std::string* Extension::release_data() {}
inline void Extension::set_allocated_data(std::string* data) {}

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

// IqStanza

// optional int64 rmq_id = 1;
inline bool IqStanza::_internal_has_rmq_id() const {}
inline bool IqStanza::has_rmq_id() const {}
inline void IqStanza::clear_rmq_id() {}
inline int64_t IqStanza::_internal_rmq_id() const {}
inline int64_t IqStanza::rmq_id() const {}
inline void IqStanza::_internal_set_rmq_id(int64_t value) {}
inline void IqStanza::set_rmq_id(int64_t value) {}

// required .mcs_proto.IqStanza.IqType type = 2;
inline bool IqStanza::_internal_has_type() const {}
inline bool IqStanza::has_type() const {}
inline void IqStanza::clear_type() {}
inline ::mcs_proto::IqStanza_IqType IqStanza::_internal_type() const {}
inline ::mcs_proto::IqStanza_IqType IqStanza::type() const {}
inline void IqStanza::_internal_set_type(::mcs_proto::IqStanza_IqType value) {}
inline void IqStanza::set_type(::mcs_proto::IqStanza_IqType value) {}

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

// optional string from = 4;
inline bool IqStanza::_internal_has_from() const {}
inline bool IqStanza::has_from() const {}
inline void IqStanza::clear_from() {}
inline const std::string& IqStanza::from() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IqStanza::set_from(ArgT0&& arg0, ArgT... args) {}
inline std::string* IqStanza::mutable_from() {}
inline const std::string& IqStanza::_internal_from() const {}
inline void IqStanza::_internal_set_from(const std::string& value) {}
inline std::string* IqStanza::_internal_mutable_from() {}
inline std::string* IqStanza::release_from() {}
inline void IqStanza::set_allocated_from(std::string* from) {}

// optional string to = 5;
inline bool IqStanza::_internal_has_to() const {}
inline bool IqStanza::has_to() const {}
inline void IqStanza::clear_to() {}
inline const std::string& IqStanza::to() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IqStanza::set_to(ArgT0&& arg0, ArgT... args) {}
inline std::string* IqStanza::mutable_to() {}
inline const std::string& IqStanza::_internal_to() const {}
inline void IqStanza::_internal_set_to(const std::string& value) {}
inline std::string* IqStanza::_internal_mutable_to() {}
inline std::string* IqStanza::release_to() {}
inline void IqStanza::set_allocated_to(std::string* to) {}

// optional .mcs_proto.ErrorInfo error = 6;
inline bool IqStanza::_internal_has_error() const {}
inline bool IqStanza::has_error() const {}
inline void IqStanza::clear_error() {}
inline const ::mcs_proto::ErrorInfo& IqStanza::_internal_error() const {}
inline const ::mcs_proto::ErrorInfo& IqStanza::error() const {}
inline void IqStanza::unsafe_arena_set_allocated_error(
::mcs_proto::ErrorInfo* error) {}
inline ::mcs_proto::ErrorInfo* IqStanza::release_error() {}
inline ::mcs_proto::ErrorInfo* IqStanza::unsafe_arena_release_error() {}
inline ::mcs_proto::ErrorInfo* IqStanza::_internal_mutable_error() {}
inline ::mcs_proto::ErrorInfo* IqStanza::mutable_error() {}
inline void IqStanza::set_allocated_error(::mcs_proto::ErrorInfo* error) {}

// optional .mcs_proto.Extension extension = 7;
inline bool IqStanza::_internal_has_extension() const {}
inline bool IqStanza::has_extension() const {}
inline void IqStanza::clear_extension() {}
inline const ::mcs_proto::Extension& IqStanza::_internal_extension() const {}
inline const ::mcs_proto::Extension& IqStanza::extension() const {}
inline void IqStanza::unsafe_arena_set_allocated_extension(
::mcs_proto::Extension* extension) {}
inline ::mcs_proto::Extension* IqStanza::release_extension() {}
inline ::mcs_proto::Extension* IqStanza::unsafe_arena_release_extension() {}
inline ::mcs_proto::Extension* IqStanza::_internal_mutable_extension() {}
inline ::mcs_proto::Extension* IqStanza::mutable_extension() {}
inline void IqStanza::set_allocated_extension(::mcs_proto::Extension* extension) {}

// optional string persistent_id = 8;
inline bool IqStanza::_internal_has_persistent_id() const {}
inline bool IqStanza::has_persistent_id() const {}
inline void IqStanza::clear_persistent_id() {}
inline const std::string& IqStanza::persistent_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IqStanza::set_persistent_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* IqStanza::mutable_persistent_id() {}
inline const std::string& IqStanza::_internal_persistent_id() const {}
inline void IqStanza::_internal_set_persistent_id(const std::string& value) {}
inline std::string* IqStanza::_internal_mutable_persistent_id() {}
inline std::string* IqStanza::release_persistent_id() {}
inline void IqStanza::set_allocated_persistent_id(std::string* persistent_id) {}

// optional int32 stream_id = 9;
inline bool IqStanza::_internal_has_stream_id() const {}
inline bool IqStanza::has_stream_id() const {}
inline void IqStanza::clear_stream_id() {}
inline int32_t IqStanza::_internal_stream_id() const {}
inline int32_t IqStanza::stream_id() const {}
inline void IqStanza::_internal_set_stream_id(int32_t value) {}
inline void IqStanza::set_stream_id(int32_t value) {}

// optional int32 last_stream_id_received = 10;
inline bool IqStanza::_internal_has_last_stream_id_received() const {}
inline bool IqStanza::has_last_stream_id_received() const {}
inline void IqStanza::clear_last_stream_id_received() {}
inline int32_t IqStanza::_internal_last_stream_id_received() const {}
inline int32_t IqStanza::last_stream_id_received() const {}
inline void IqStanza::_internal_set_last_stream_id_received(int32_t value) {}
inline void IqStanza::set_last_stream_id_received(int32_t value) {}

// optional int64 account_id = 11;
inline bool IqStanza::_internal_has_account_id() const {}
inline bool IqStanza::has_account_id() const {}
inline void IqStanza::clear_account_id() {}
inline int64_t IqStanza::_internal_account_id() const {}
inline int64_t IqStanza::account_id() const {}
inline void IqStanza::_internal_set_account_id(int64_t value) {}
inline void IqStanza::set_account_id(int64_t value) {}

// optional int64 status = 12;
inline bool IqStanza::_internal_has_status() const {}
inline bool IqStanza::has_status() const {}
inline void IqStanza::clear_status() {}
inline int64_t IqStanza::_internal_status() const {}
inline int64_t IqStanza::status() const {}
inline void IqStanza::_internal_set_status(int64_t value) {}
inline void IqStanza::set_status(int64_t value) {}

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

// AppData

// required string key = 1;
inline bool AppData::_internal_has_key() const {}
inline bool AppData::has_key() const {}
inline void AppData::clear_key() {}
inline const std::string& AppData::key() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AppData::set_key(ArgT0&& arg0, ArgT... args) {}
inline std::string* AppData::mutable_key() {}
inline const std::string& AppData::_internal_key() const {}
inline void AppData::_internal_set_key(const std::string& value) {}
inline std::string* AppData::_internal_mutable_key() {}
inline std::string* AppData::release_key() {}
inline void AppData::set_allocated_key(std::string* key) {}

// required string value = 2;
inline bool AppData::_internal_has_value() const {}
inline bool AppData::has_value() const {}
inline void AppData::clear_value() {}
inline const std::string& AppData::value() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AppData::set_value(ArgT0&& arg0, ArgT... args) {}
inline std::string* AppData::mutable_value() {}
inline const std::string& AppData::_internal_value() const {}
inline void AppData::_internal_set_value(const std::string& value) {}
inline std::string* AppData::_internal_mutable_value() {}
inline std::string* AppData::release_value() {}
inline void AppData::set_allocated_value(std::string* value) {}

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

// DataMessageStanza

// optional string id = 2;
inline bool DataMessageStanza::_internal_has_id() const {}
inline bool DataMessageStanza::has_id() const {}
inline void DataMessageStanza::clear_id() {}
inline const std::string& DataMessageStanza::id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_id() {}
inline const std::string& DataMessageStanza::_internal_id() const {}
inline void DataMessageStanza::_internal_set_id(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_id() {}
inline std::string* DataMessageStanza::release_id() {}
inline void DataMessageStanza::set_allocated_id(std::string* id) {}

// required string from = 3;
inline bool DataMessageStanza::_internal_has_from() const {}
inline bool DataMessageStanza::has_from() const {}
inline void DataMessageStanza::clear_from() {}
inline const std::string& DataMessageStanza::from() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_from(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_from() {}
inline const std::string& DataMessageStanza::_internal_from() const {}
inline void DataMessageStanza::_internal_set_from(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_from() {}
inline std::string* DataMessageStanza::release_from() {}
inline void DataMessageStanza::set_allocated_from(std::string* from) {}

// optional string to = 4;
inline bool DataMessageStanza::_internal_has_to() const {}
inline bool DataMessageStanza::has_to() const {}
inline void DataMessageStanza::clear_to() {}
inline const std::string& DataMessageStanza::to() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_to(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_to() {}
inline const std::string& DataMessageStanza::_internal_to() const {}
inline void DataMessageStanza::_internal_set_to(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_to() {}
inline std::string* DataMessageStanza::release_to() {}
inline void DataMessageStanza::set_allocated_to(std::string* to) {}

// required string category = 5;
inline bool DataMessageStanza::_internal_has_category() const {}
inline bool DataMessageStanza::has_category() const {}
inline void DataMessageStanza::clear_category() {}
inline const std::string& DataMessageStanza::category() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_category(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_category() {}
inline const std::string& DataMessageStanza::_internal_category() const {}
inline void DataMessageStanza::_internal_set_category(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_category() {}
inline std::string* DataMessageStanza::release_category() {}
inline void DataMessageStanza::set_allocated_category(std::string* category) {}

// optional string token = 6;
inline bool DataMessageStanza::_internal_has_token() const {}
inline bool DataMessageStanza::has_token() const {}
inline void DataMessageStanza::clear_token() {}
inline const std::string& DataMessageStanza::token() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_token(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_token() {}
inline const std::string& DataMessageStanza::_internal_token() const {}
inline void DataMessageStanza::_internal_set_token(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_token() {}
inline std::string* DataMessageStanza::release_token() {}
inline void DataMessageStanza::set_allocated_token(std::string* token) {}

// repeated .mcs_proto.AppData app_data = 7;
inline int DataMessageStanza::_internal_app_data_size() const {}
inline int DataMessageStanza::app_data_size() const {}
inline void DataMessageStanza::clear_app_data() {}
inline ::mcs_proto::AppData* DataMessageStanza::mutable_app_data(int index) {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::AppData >*
DataMessageStanza::mutable_app_data() {}
inline const ::mcs_proto::AppData& DataMessageStanza::_internal_app_data(int index) const {}
inline const ::mcs_proto::AppData& DataMessageStanza::app_data(int index) const {}
inline ::mcs_proto::AppData* DataMessageStanza::_internal_add_app_data() {}
inline ::mcs_proto::AppData* DataMessageStanza::add_app_data() {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::mcs_proto::AppData >&
DataMessageStanza::app_data() const {}

// optional bool from_trusted_server = 8;
inline bool DataMessageStanza::_internal_has_from_trusted_server() const {}
inline bool DataMessageStanza::has_from_trusted_server() const {}
inline void DataMessageStanza::clear_from_trusted_server() {}
inline bool DataMessageStanza::_internal_from_trusted_server() const {}
inline bool DataMessageStanza::from_trusted_server() const {}
inline void DataMessageStanza::_internal_set_from_trusted_server(bool value) {}
inline void DataMessageStanza::set_from_trusted_server(bool value) {}

// optional string persistent_id = 9;
inline bool DataMessageStanza::_internal_has_persistent_id() const {}
inline bool DataMessageStanza::has_persistent_id() const {}
inline void DataMessageStanza::clear_persistent_id() {}
inline const std::string& DataMessageStanza::persistent_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_persistent_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_persistent_id() {}
inline const std::string& DataMessageStanza::_internal_persistent_id() const {}
inline void DataMessageStanza::_internal_set_persistent_id(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_persistent_id() {}
inline std::string* DataMessageStanza::release_persistent_id() {}
inline void DataMessageStanza::set_allocated_persistent_id(std::string* persistent_id) {}

// optional int32 stream_id = 10;
inline bool DataMessageStanza::_internal_has_stream_id() const {}
inline bool DataMessageStanza::has_stream_id() const {}
inline void DataMessageStanza::clear_stream_id() {}
inline int32_t DataMessageStanza::_internal_stream_id() const {}
inline int32_t DataMessageStanza::stream_id() const {}
inline void DataMessageStanza::_internal_set_stream_id(int32_t value) {}
inline void DataMessageStanza::set_stream_id(int32_t value) {}

// optional int32 last_stream_id_received = 11;
inline bool DataMessageStanza::_internal_has_last_stream_id_received() const {}
inline bool DataMessageStanza::has_last_stream_id_received() const {}
inline void DataMessageStanza::clear_last_stream_id_received() {}
inline int32_t DataMessageStanza::_internal_last_stream_id_received() const {}
inline int32_t DataMessageStanza::last_stream_id_received() const {}
inline void DataMessageStanza::_internal_set_last_stream_id_received(int32_t value) {}
inline void DataMessageStanza::set_last_stream_id_received(int32_t value) {}

// optional string reg_id = 13;
inline bool DataMessageStanza::_internal_has_reg_id() const {}
inline bool DataMessageStanza::has_reg_id() const {}
inline void DataMessageStanza::clear_reg_id() {}
inline const std::string& DataMessageStanza::reg_id() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_reg_id(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_reg_id() {}
inline const std::string& DataMessageStanza::_internal_reg_id() const {}
inline void DataMessageStanza::_internal_set_reg_id(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_reg_id() {}
inline std::string* DataMessageStanza::release_reg_id() {}
inline void DataMessageStanza::set_allocated_reg_id(std::string* reg_id) {}

// optional int64 device_user_id = 16;
inline bool DataMessageStanza::_internal_has_device_user_id() const {}
inline bool DataMessageStanza::has_device_user_id() const {}
inline void DataMessageStanza::clear_device_user_id() {}
inline int64_t DataMessageStanza::_internal_device_user_id() const {}
inline int64_t DataMessageStanza::device_user_id() const {}
inline void DataMessageStanza::_internal_set_device_user_id(int64_t value) {}
inline void DataMessageStanza::set_device_user_id(int64_t value) {}

// optional int32 ttl = 17;
inline bool DataMessageStanza::_internal_has_ttl() const {}
inline bool DataMessageStanza::has_ttl() const {}
inline void DataMessageStanza::clear_ttl() {}
inline int32_t DataMessageStanza::_internal_ttl() const {}
inline int32_t DataMessageStanza::ttl() const {}
inline void DataMessageStanza::_internal_set_ttl(int32_t value) {}
inline void DataMessageStanza::set_ttl(int32_t value) {}

// optional int64 sent = 18;
inline bool DataMessageStanza::_internal_has_sent() const {}
inline bool DataMessageStanza::has_sent() const {}
inline void DataMessageStanza::clear_sent() {}
inline int64_t DataMessageStanza::_internal_sent() const {}
inline int64_t DataMessageStanza::sent() const {}
inline void DataMessageStanza::_internal_set_sent(int64_t value) {}
inline void DataMessageStanza::set_sent(int64_t value) {}

// optional int32 queued = 19;
inline bool DataMessageStanza::_internal_has_queued() const {}
inline bool DataMessageStanza::has_queued() const {}
inline void DataMessageStanza::clear_queued() {}
inline int32_t DataMessageStanza::_internal_queued() const {}
inline int32_t DataMessageStanza::queued() const {}
inline void DataMessageStanza::_internal_set_queued(int32_t value) {}
inline void DataMessageStanza::set_queued(int32_t value) {}

// optional int64 status = 20;
inline bool DataMessageStanza::_internal_has_status() const {}
inline bool DataMessageStanza::has_status() const {}
inline void DataMessageStanza::clear_status() {}
inline int64_t DataMessageStanza::_internal_status() const {}
inline int64_t DataMessageStanza::status() const {}
inline void DataMessageStanza::_internal_set_status(int64_t value) {}
inline void DataMessageStanza::set_status(int64_t value) {}

// optional bytes raw_data = 21;
inline bool DataMessageStanza::_internal_has_raw_data() const {}
inline bool DataMessageStanza::has_raw_data() const {}
inline void DataMessageStanza::clear_raw_data() {}
inline const std::string& DataMessageStanza::raw_data() const {}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DataMessageStanza::set_raw_data(ArgT0&& arg0, ArgT... args) {}
inline std::string* DataMessageStanza::mutable_raw_data() {}
inline const std::string& DataMessageStanza::_internal_raw_data() const {}
inline void DataMessageStanza::_internal_set_raw_data(const std::string& value) {}
inline std::string* DataMessageStanza::_internal_mutable_raw_data() {}
inline std::string* DataMessageStanza::release_raw_data() {}
inline void DataMessageStanza::set_allocated_raw_data(std::string* raw_data) {}

// optional bool immediate_ack = 24;
inline bool DataMessageStanza::_internal_has_immediate_ack() const {}
inline bool DataMessageStanza::has_immediate_ack() const {}
inline void DataMessageStanza::clear_immediate_ack() {}
inline bool DataMessageStanza::_internal_immediate_ack() const {}
inline bool DataMessageStanza::immediate_ack() const {}
inline void DataMessageStanza::_internal_set_immediate_ack(bool value) {}
inline void DataMessageStanza::set_immediate_ack(bool value) {}

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

// StreamAck

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

// SelectiveAck

// repeated string id = 1;
inline int SelectiveAck::_internal_id_size() const {}
inline int SelectiveAck::id_size() const {}
inline void SelectiveAck::clear_id() {}
inline std::string* SelectiveAck::add_id() {}
inline const std::string& SelectiveAck::_internal_id(int index) const {}
inline const std::string& SelectiveAck::id(int index) const {}
inline std::string* SelectiveAck::mutable_id(int index) {}
inline void SelectiveAck::set_id(int index, const std::string& value) {}
inline void SelectiveAck::set_id(int index, std::string&& value) {}
inline void SelectiveAck::set_id(int index, const char* value) {}
inline void SelectiveAck::set_id(int index, const char* value, size_t size) {}
inline std::string* SelectiveAck::_internal_add_id() {}
inline void SelectiveAck::add_id(const std::string& value) {}
inline void SelectiveAck::add_id(std::string&& value) {}
inline void SelectiveAck::add_id(const char* value) {}
inline void SelectiveAck::add_id(const char* value, size_t size) {}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SelectiveAck::id() const {}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SelectiveAck::mutable_id() {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace mcs_proto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::mcs_proto::ClientEvent_Type> : ::std::true_type {};
template <> struct is_proto_enum< ::mcs_proto::LoginRequest_AuthService> : ::std::true_type {};
template <> struct is_proto_enum< ::mcs_proto::IqStanza_IqType> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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