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

#include "bridge.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace grpc {
constexpr PointResponse::PointResponse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : x_(0)
  , y_(0){}
struct PointResponseDefaultTypeInternal {
  constexpr PointResponseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PointResponseDefaultTypeInternal() {}
  union {
    PointResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PointResponseDefaultTypeInternal _PointResponse_default_instance_;
constexpr ReportBugRequest::ReportBugRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : description_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , emailclient_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , includelogs_(false){}
struct ReportBugRequestDefaultTypeInternal {
  constexpr ReportBugRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReportBugRequestDefaultTypeInternal() {}
  union {
    ReportBugRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReportBugRequestDefaultTypeInternal _ReportBugRequest_default_instance_;
constexpr LoginRequest::LoginRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct LoginRequestDefaultTypeInternal {
  constexpr LoginRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginRequestDefaultTypeInternal() {}
  union {
    LoginRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
constexpr LoginAbortRequest::LoginAbortRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct LoginAbortRequestDefaultTypeInternal {
  constexpr LoginAbortRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginAbortRequestDefaultTypeInternal() {}
  union {
    LoginAbortRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginAbortRequestDefaultTypeInternal _LoginAbortRequest_default_instance_;
constexpr ChangeLocalCacheRequest::ChangeLocalCacheRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : diskcachepath_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , enablediskcache_(false){}
struct ChangeLocalCacheRequestDefaultTypeInternal {
  constexpr ChangeLocalCacheRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ChangeLocalCacheRequestDefaultTypeInternal() {}
  union {
    ChangeLocalCacheRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ChangeLocalCacheRequestDefaultTypeInternal _ChangeLocalCacheRequest_default_instance_;
constexpr ChangePortsRequest::ChangePortsRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : imapport_(0)
  , smtpport_(0){}
struct ChangePortsRequestDefaultTypeInternal {
  constexpr ChangePortsRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ChangePortsRequestDefaultTypeInternal() {}
  union {
    ChangePortsRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ChangePortsRequestDefaultTypeInternal _ChangePortsRequest_default_instance_;
constexpr AvailableKeychainsResponse::AvailableKeychainsResponse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : keychains_(){}
struct AvailableKeychainsResponseDefaultTypeInternal {
  constexpr AvailableKeychainsResponseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AvailableKeychainsResponseDefaultTypeInternal() {}
  union {
    AvailableKeychainsResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AvailableKeychainsResponseDefaultTypeInternal _AvailableKeychainsResponse_default_instance_;
constexpr User::User(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : addresses_()
  , id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , avatartext_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , usedbytes_(int64_t{0})
  , totalbytes_(int64_t{0})
  , loggedin_(false)
  , splitmode_(false)
  , setupguideseen_(false){}
struct UserDefaultTypeInternal {
  constexpr UserDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserDefaultTypeInternal() {}
  union {
    User _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserDefaultTypeInternal _User_default_instance_;
constexpr UserSplitModeRequest::UserSplitModeRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , active_(false){}
struct UserSplitModeRequestDefaultTypeInternal {
  constexpr UserSplitModeRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserSplitModeRequestDefaultTypeInternal() {}
  union {
    UserSplitModeRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserSplitModeRequestDefaultTypeInternal _UserSplitModeRequest_default_instance_;
constexpr UserListResponse::UserListResponse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : users_(){}
struct UserListResponseDefaultTypeInternal {
  constexpr UserListResponseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserListResponseDefaultTypeInternal() {}
  union {
    UserListResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserListResponseDefaultTypeInternal _UserListResponse_default_instance_;
constexpr ConfigureAppleMailRequest::ConfigureAppleMailRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct ConfigureAppleMailRequestDefaultTypeInternal {
  constexpr ConfigureAppleMailRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ConfigureAppleMailRequestDefaultTypeInternal() {}
  union {
    ConfigureAppleMailRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConfigureAppleMailRequestDefaultTypeInternal _ConfigureAppleMailRequest_default_instance_;
constexpr StreamEvent::StreamEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct StreamEventDefaultTypeInternal {
  constexpr StreamEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~StreamEventDefaultTypeInternal() {}
  union {
    StreamEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT StreamEventDefaultTypeInternal _StreamEvent_default_instance_;
constexpr AppEvent::AppEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct AppEventDefaultTypeInternal {
  constexpr AppEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AppEventDefaultTypeInternal() {}
  union {
    AppEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AppEventDefaultTypeInternal _AppEvent_default_instance_;
constexpr InternetStatusEvent::InternetStatusEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : connected_(false){}
struct InternetStatusEventDefaultTypeInternal {
  constexpr InternetStatusEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~InternetStatusEventDefaultTypeInternal() {}
  union {
    InternetStatusEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT InternetStatusEventDefaultTypeInternal _InternetStatusEvent_default_instance_;
constexpr AutostartFinishedEvent::AutostartFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct AutostartFinishedEventDefaultTypeInternal {
  constexpr AutostartFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AutostartFinishedEventDefaultTypeInternal() {}
  union {
    AutostartFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AutostartFinishedEventDefaultTypeInternal _AutostartFinishedEvent_default_instance_;
constexpr ResetFinishedEvent::ResetFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ResetFinishedEventDefaultTypeInternal {
  constexpr ResetFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ResetFinishedEventDefaultTypeInternal() {}
  union {
    ResetFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ResetFinishedEventDefaultTypeInternal _ResetFinishedEvent_default_instance_;
constexpr ReportBugFinishedEvent::ReportBugFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ReportBugFinishedEventDefaultTypeInternal {
  constexpr ReportBugFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReportBugFinishedEventDefaultTypeInternal() {}
  union {
    ReportBugFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReportBugFinishedEventDefaultTypeInternal _ReportBugFinishedEvent_default_instance_;
constexpr ReportBugSuccessEvent::ReportBugSuccessEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ReportBugSuccessEventDefaultTypeInternal {
  constexpr ReportBugSuccessEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReportBugSuccessEventDefaultTypeInternal() {}
  union {
    ReportBugSuccessEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReportBugSuccessEventDefaultTypeInternal _ReportBugSuccessEvent_default_instance_;
constexpr ReportBugErrorEvent::ReportBugErrorEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ReportBugErrorEventDefaultTypeInternal {
  constexpr ReportBugErrorEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ReportBugErrorEventDefaultTypeInternal() {}
  union {
    ReportBugErrorEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReportBugErrorEventDefaultTypeInternal _ReportBugErrorEvent_default_instance_;
constexpr ShowMainWindowEvent::ShowMainWindowEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ShowMainWindowEventDefaultTypeInternal {
  constexpr ShowMainWindowEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ShowMainWindowEventDefaultTypeInternal() {}
  union {
    ShowMainWindowEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ShowMainWindowEventDefaultTypeInternal _ShowMainWindowEvent_default_instance_;
constexpr LoginEvent::LoginEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct LoginEventDefaultTypeInternal {
  constexpr LoginEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginEventDefaultTypeInternal() {}
  union {
    LoginEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginEventDefaultTypeInternal _LoginEvent_default_instance_;
constexpr LoginErrorEvent::LoginErrorEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , type_(0)
{}
struct LoginErrorEventDefaultTypeInternal {
  constexpr LoginErrorEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginErrorEventDefaultTypeInternal() {}
  union {
    LoginErrorEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginErrorEventDefaultTypeInternal _LoginErrorEvent_default_instance_;
constexpr LoginTfaRequestedEvent::LoginTfaRequestedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct LoginTfaRequestedEventDefaultTypeInternal {
  constexpr LoginTfaRequestedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginTfaRequestedEventDefaultTypeInternal() {}
  union {
    LoginTfaRequestedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginTfaRequestedEventDefaultTypeInternal _LoginTfaRequestedEvent_default_instance_;
constexpr LoginTwoPasswordsRequestedEvent::LoginTwoPasswordsRequestedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct LoginTwoPasswordsRequestedEventDefaultTypeInternal {
  constexpr LoginTwoPasswordsRequestedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginTwoPasswordsRequestedEventDefaultTypeInternal() {}
  union {
    LoginTwoPasswordsRequestedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginTwoPasswordsRequestedEventDefaultTypeInternal _LoginTwoPasswordsRequestedEvent_default_instance_;
constexpr LoginFinishedEvent::LoginFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : wasalreadyloggedin_(false){}
struct LoginFinishedEventDefaultTypeInternal {
  constexpr LoginFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~LoginFinishedEventDefaultTypeInternal() {}
  union {
    LoginFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LoginFinishedEventDefaultTypeInternal _LoginFinishedEvent_default_instance_;
constexpr UpdateEvent::UpdateEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct UpdateEventDefaultTypeInternal {
  constexpr UpdateEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateEventDefaultTypeInternal() {}
  union {
    UpdateEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateEventDefaultTypeInternal _UpdateEvent_default_instance_;
constexpr UpdateErrorEvent::UpdateErrorEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(0)
{}
struct UpdateErrorEventDefaultTypeInternal {
  constexpr UpdateErrorEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateErrorEventDefaultTypeInternal() {}
  union {
    UpdateErrorEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateErrorEventDefaultTypeInternal _UpdateErrorEvent_default_instance_;
constexpr UpdateManualReadyEvent::UpdateManualReadyEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : version_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct UpdateManualReadyEventDefaultTypeInternal {
  constexpr UpdateManualReadyEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateManualReadyEventDefaultTypeInternal() {}
  union {
    UpdateManualReadyEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateManualReadyEventDefaultTypeInternal _UpdateManualReadyEvent_default_instance_;
constexpr UpdateManualRestartNeededEvent::UpdateManualRestartNeededEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct UpdateManualRestartNeededEventDefaultTypeInternal {
  constexpr UpdateManualRestartNeededEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateManualRestartNeededEventDefaultTypeInternal() {}
  union {
    UpdateManualRestartNeededEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateManualRestartNeededEventDefaultTypeInternal _UpdateManualRestartNeededEvent_default_instance_;
constexpr UpdateForceEvent::UpdateForceEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : version_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct UpdateForceEventDefaultTypeInternal {
  constexpr UpdateForceEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateForceEventDefaultTypeInternal() {}
  union {
    UpdateForceEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateForceEventDefaultTypeInternal _UpdateForceEvent_default_instance_;
constexpr UpdateSilentRestartNeeded::UpdateSilentRestartNeeded(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct UpdateSilentRestartNeededDefaultTypeInternal {
  constexpr UpdateSilentRestartNeededDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateSilentRestartNeededDefaultTypeInternal() {}
  union {
    UpdateSilentRestartNeeded _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateSilentRestartNeededDefaultTypeInternal _UpdateSilentRestartNeeded_default_instance_;
constexpr UpdateIsLatestVersion::UpdateIsLatestVersion(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct UpdateIsLatestVersionDefaultTypeInternal {
  constexpr UpdateIsLatestVersionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateIsLatestVersionDefaultTypeInternal() {}
  union {
    UpdateIsLatestVersion _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateIsLatestVersionDefaultTypeInternal _UpdateIsLatestVersion_default_instance_;
constexpr UpdateCheckFinished::UpdateCheckFinished(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct UpdateCheckFinishedDefaultTypeInternal {
  constexpr UpdateCheckFinishedDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UpdateCheckFinishedDefaultTypeInternal() {}
  union {
    UpdateCheckFinished _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UpdateCheckFinishedDefaultTypeInternal _UpdateCheckFinished_default_instance_;
constexpr CacheEvent::CacheEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct CacheEventDefaultTypeInternal {
  constexpr CacheEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CacheEventDefaultTypeInternal() {}
  union {
    CacheEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CacheEventDefaultTypeInternal _CacheEvent_default_instance_;
constexpr CacheErrorEvent::CacheErrorEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(0)
{}
struct CacheErrorEventDefaultTypeInternal {
  constexpr CacheErrorEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CacheErrorEventDefaultTypeInternal() {}
  union {
    CacheErrorEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CacheErrorEventDefaultTypeInternal _CacheErrorEvent_default_instance_;
constexpr CacheLocationChangeSuccessEvent::CacheLocationChangeSuccessEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct CacheLocationChangeSuccessEventDefaultTypeInternal {
  constexpr CacheLocationChangeSuccessEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~CacheLocationChangeSuccessEventDefaultTypeInternal() {}
  union {
    CacheLocationChangeSuccessEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CacheLocationChangeSuccessEventDefaultTypeInternal _CacheLocationChangeSuccessEvent_default_instance_;
constexpr ChangeLocalCacheFinishedEvent::ChangeLocalCacheFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ChangeLocalCacheFinishedEventDefaultTypeInternal {
  constexpr ChangeLocalCacheFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ChangeLocalCacheFinishedEventDefaultTypeInternal() {}
  union {
    ChangeLocalCacheFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ChangeLocalCacheFinishedEventDefaultTypeInternal _ChangeLocalCacheFinishedEvent_default_instance_;
constexpr MailSettingsEvent::MailSettingsEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct MailSettingsEventDefaultTypeInternal {
  constexpr MailSettingsEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MailSettingsEventDefaultTypeInternal() {}
  union {
    MailSettingsEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MailSettingsEventDefaultTypeInternal _MailSettingsEvent_default_instance_;
constexpr MailSettingsErrorEvent::MailSettingsErrorEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : type_(0)
{}
struct MailSettingsErrorEventDefaultTypeInternal {
  constexpr MailSettingsErrorEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MailSettingsErrorEventDefaultTypeInternal() {}
  union {
    MailSettingsErrorEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MailSettingsErrorEventDefaultTypeInternal _MailSettingsErrorEvent_default_instance_;
constexpr UseSslForSmtpFinishedEvent::UseSslForSmtpFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct UseSslForSmtpFinishedEventDefaultTypeInternal {
  constexpr UseSslForSmtpFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UseSslForSmtpFinishedEventDefaultTypeInternal() {}
  union {
    UseSslForSmtpFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UseSslForSmtpFinishedEventDefaultTypeInternal _UseSslForSmtpFinishedEvent_default_instance_;
constexpr ChangePortsFinishedEvent::ChangePortsFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ChangePortsFinishedEventDefaultTypeInternal {
  constexpr ChangePortsFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ChangePortsFinishedEventDefaultTypeInternal() {}
  union {
    ChangePortsFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ChangePortsFinishedEventDefaultTypeInternal _ChangePortsFinishedEvent_default_instance_;
constexpr KeychainEvent::KeychainEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct KeychainEventDefaultTypeInternal {
  constexpr KeychainEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~KeychainEventDefaultTypeInternal() {}
  union {
    KeychainEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT KeychainEventDefaultTypeInternal _KeychainEvent_default_instance_;
constexpr ChangeKeychainFinishedEvent::ChangeKeychainFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ChangeKeychainFinishedEventDefaultTypeInternal {
  constexpr ChangeKeychainFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ChangeKeychainFinishedEventDefaultTypeInternal() {}
  union {
    ChangeKeychainFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ChangeKeychainFinishedEventDefaultTypeInternal _ChangeKeychainFinishedEvent_default_instance_;
constexpr HasNoKeychainEvent::HasNoKeychainEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct HasNoKeychainEventDefaultTypeInternal {
  constexpr HasNoKeychainEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~HasNoKeychainEventDefaultTypeInternal() {}
  union {
    HasNoKeychainEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT HasNoKeychainEventDefaultTypeInternal _HasNoKeychainEvent_default_instance_;
constexpr RebuildKeychainEvent::RebuildKeychainEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct RebuildKeychainEventDefaultTypeInternal {
  constexpr RebuildKeychainEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~RebuildKeychainEventDefaultTypeInternal() {}
  union {
    RebuildKeychainEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RebuildKeychainEventDefaultTypeInternal _RebuildKeychainEvent_default_instance_;
constexpr MailEvent::MailEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct MailEventDefaultTypeInternal {
  constexpr MailEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MailEventDefaultTypeInternal() {}
  union {
    MailEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MailEventDefaultTypeInternal _MailEvent_default_instance_;
constexpr NoActiveKeyForRecipientEvent::NoActiveKeyForRecipientEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : email_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct NoActiveKeyForRecipientEventDefaultTypeInternal {
  constexpr NoActiveKeyForRecipientEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~NoActiveKeyForRecipientEventDefaultTypeInternal() {}
  union {
    NoActiveKeyForRecipientEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NoActiveKeyForRecipientEventDefaultTypeInternal _NoActiveKeyForRecipientEvent_default_instance_;
constexpr AddressChangedEvent::AddressChangedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct AddressChangedEventDefaultTypeInternal {
  constexpr AddressChangedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AddressChangedEventDefaultTypeInternal() {}
  union {
    AddressChangedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AddressChangedEventDefaultTypeInternal _AddressChangedEvent_default_instance_;
constexpr AddressChangedLogoutEvent::AddressChangedLogoutEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct AddressChangedLogoutEventDefaultTypeInternal {
  constexpr AddressChangedLogoutEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~AddressChangedLogoutEventDefaultTypeInternal() {}
  union {
    AddressChangedLogoutEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AddressChangedLogoutEventDefaultTypeInternal _AddressChangedLogoutEvent_default_instance_;
constexpr ApiCertIssueEvent::ApiCertIssueEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct ApiCertIssueEventDefaultTypeInternal {
  constexpr ApiCertIssueEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ApiCertIssueEventDefaultTypeInternal() {}
  union {
    ApiCertIssueEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ApiCertIssueEventDefaultTypeInternal _ApiCertIssueEvent_default_instance_;
constexpr UserEvent::UserEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : _oneof_case_{}{}
struct UserEventDefaultTypeInternal {
  constexpr UserEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserEventDefaultTypeInternal() {}
  union {
    UserEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserEventDefaultTypeInternal _UserEvent_default_instance_;
constexpr ToggleSplitModeFinishedEvent::ToggleSplitModeFinishedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : userid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct ToggleSplitModeFinishedEventDefaultTypeInternal {
  constexpr ToggleSplitModeFinishedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~ToggleSplitModeFinishedEventDefaultTypeInternal() {}
  union {
    ToggleSplitModeFinishedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ToggleSplitModeFinishedEventDefaultTypeInternal _ToggleSplitModeFinishedEvent_default_instance_;
constexpr UserDisconnectedEvent::UserDisconnectedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct UserDisconnectedEventDefaultTypeInternal {
  constexpr UserDisconnectedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserDisconnectedEventDefaultTypeInternal() {}
  union {
    UserDisconnectedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserDisconnectedEventDefaultTypeInternal _UserDisconnectedEvent_default_instance_;
constexpr UserChangedEvent::UserChangedEvent(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : user_(nullptr){}
struct UserChangedEventDefaultTypeInternal {
  constexpr UserChangedEventDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~UserChangedEventDefaultTypeInternal() {}
  union {
    UserChangedEvent _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT UserChangedEventDefaultTypeInternal _UserChangedEvent_default_instance_;
}  // namespace grpc
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_bridge_2eproto[54];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_bridge_2eproto[4];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_bridge_2eproto = nullptr;

const uint32_t TableStruct_bridge_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::PointResponse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::PointResponse, x_),
  PROTOBUF_FIELD_OFFSET(::grpc::PointResponse, y_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugRequest, description_),
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugRequest, address_),
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugRequest, emailclient_),
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugRequest, includelogs_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginRequest, username_),
  PROTOBUF_FIELD_OFFSET(::grpc::LoginRequest, password_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginAbortRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginAbortRequest, username_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangeLocalCacheRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangeLocalCacheRequest, enablediskcache_),
  PROTOBUF_FIELD_OFFSET(::grpc::ChangeLocalCacheRequest, diskcachepath_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangePortsRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangePortsRequest, imapport_),
  PROTOBUF_FIELD_OFFSET(::grpc::ChangePortsRequest, smtpport_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::AvailableKeychainsResponse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::AvailableKeychainsResponse, keychains_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::User, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::User, id_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, username_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, avatartext_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, loggedin_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, splitmode_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, setupguideseen_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, usedbytes_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, totalbytes_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, password_),
  PROTOBUF_FIELD_OFFSET(::grpc::User, addresses_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UserSplitModeRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UserSplitModeRequest, userid_),
  PROTOBUF_FIELD_OFFSET(::grpc::UserSplitModeRequest, active_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UserListResponse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UserListResponse, users_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ConfigureAppleMailRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::ConfigureAppleMailRequest, userid_),
  PROTOBUF_FIELD_OFFSET(::grpc::ConfigureAppleMailRequest, address_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::StreamEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::StreamEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::StreamEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::AppEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::AppEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::AppEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::InternetStatusEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::InternetStatusEvent, connected_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::AutostartFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ResetFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugSuccessEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ReportBugErrorEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ShowMainWindowEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::LoginEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginErrorEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginErrorEvent, type_),
  PROTOBUF_FIELD_OFFSET(::grpc::LoginErrorEvent, message_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginTfaRequestedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginTfaRequestedEvent, username_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginTwoPasswordsRequestedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::LoginFinishedEvent, wasalreadyloggedin_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateErrorEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateErrorEvent, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateManualReadyEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateManualReadyEvent, version_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateManualRestartNeededEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateForceEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateForceEvent, version_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateSilentRestartNeeded, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateIsLatestVersion, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UpdateCheckFinished, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::CacheEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::CacheEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::CacheEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::CacheErrorEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::CacheErrorEvent, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::CacheLocationChangeSuccessEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangeLocalCacheFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::MailSettingsEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::MailSettingsEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::MailSettingsEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::MailSettingsErrorEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::MailSettingsErrorEvent, type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UseSslForSmtpFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangePortsFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::KeychainEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::KeychainEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::KeychainEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ChangeKeychainFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::HasNoKeychainEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::RebuildKeychainEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::MailEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::MailEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::MailEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::NoActiveKeyForRecipientEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::NoActiveKeyForRecipientEvent, email_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::AddressChangedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::AddressChangedEvent, address_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::AddressChangedLogoutEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::AddressChangedLogoutEvent, address_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ApiCertIssueEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UserEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::grpc::UserEvent, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::grpc::UserEvent, event_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::ToggleSplitModeFinishedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::ToggleSplitModeFinishedEvent, userid_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UserDisconnectedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UserDisconnectedEvent, username_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::grpc::UserChangedEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::grpc::UserChangedEvent, user_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, -1, sizeof(::grpc::PointResponse)},
  { 8, -1, -1, sizeof(::grpc::ReportBugRequest)},
  { 18, -1, -1, sizeof(::grpc::LoginRequest)},
  { 26, -1, -1, sizeof(::grpc::LoginAbortRequest)},
  { 33, -1, -1, sizeof(::grpc::ChangeLocalCacheRequest)},
  { 41, -1, -1, sizeof(::grpc::ChangePortsRequest)},
  { 49, -1, -1, sizeof(::grpc::AvailableKeychainsResponse)},
  { 56, -1, -1, sizeof(::grpc::User)},
  { 72, -1, -1, sizeof(::grpc::UserSplitModeRequest)},
  { 80, -1, -1, sizeof(::grpc::UserListResponse)},
  { 87, -1, -1, sizeof(::grpc::ConfigureAppleMailRequest)},
  { 95, -1, -1, sizeof(::grpc::StreamEvent)},
  { 110, -1, -1, sizeof(::grpc::AppEvent)},
  { 124, -1, -1, sizeof(::grpc::InternetStatusEvent)},
  { 131, -1, -1, sizeof(::grpc::AutostartFinishedEvent)},
  { 137, -1, -1, sizeof(::grpc::ResetFinishedEvent)},
  { 143, -1, -1, sizeof(::grpc::ReportBugFinishedEvent)},
  { 149, -1, -1, sizeof(::grpc::ReportBugSuccessEvent)},
  { 155, -1, -1, sizeof(::grpc::ReportBugErrorEvent)},
  { 161, -1, -1, sizeof(::grpc::ShowMainWindowEvent)},
  { 167, -1, -1, sizeof(::grpc::LoginEvent)},
  { 178, -1, -1, sizeof(::grpc::LoginErrorEvent)},
  { 186, -1, -1, sizeof(::grpc::LoginTfaRequestedEvent)},
  { 193, -1, -1, sizeof(::grpc::LoginTwoPasswordsRequestedEvent)},
  { 199, -1, -1, sizeof(::grpc::LoginFinishedEvent)},
  { 206, -1, -1, sizeof(::grpc::UpdateEvent)},
  { 220, -1, -1, sizeof(::grpc::UpdateErrorEvent)},
  { 227, -1, -1, sizeof(::grpc::UpdateManualReadyEvent)},
  { 234, -1, -1, sizeof(::grpc::UpdateManualRestartNeededEvent)},
  { 240, -1, -1, sizeof(::grpc::UpdateForceEvent)},
  { 247, -1, -1, sizeof(::grpc::UpdateSilentRestartNeeded)},
  { 253, -1, -1, sizeof(::grpc::UpdateIsLatestVersion)},
  { 259, -1, -1, sizeof(::grpc::UpdateCheckFinished)},
  { 265, -1, -1, sizeof(::grpc::CacheEvent)},
  { 275, -1, -1, sizeof(::grpc::CacheErrorEvent)},
  { 282, -1, -1, sizeof(::grpc::CacheLocationChangeSuccessEvent)},
  { 288, -1, -1, sizeof(::grpc::ChangeLocalCacheFinishedEvent)},
  { 294, -1, -1, sizeof(::grpc::MailSettingsEvent)},
  { 304, -1, -1, sizeof(::grpc::MailSettingsErrorEvent)},
  { 311, -1, -1, sizeof(::grpc::UseSslForSmtpFinishedEvent)},
  { 317, -1, -1, sizeof(::grpc::ChangePortsFinishedEvent)},
  { 323, -1, -1, sizeof(::grpc::KeychainEvent)},
  { 333, -1, -1, sizeof(::grpc::ChangeKeychainFinishedEvent)},
  { 339, -1, -1, sizeof(::grpc::HasNoKeychainEvent)},
  { 345, -1, -1, sizeof(::grpc::RebuildKeychainEvent)},
  { 351, -1, -1, sizeof(::grpc::MailEvent)},
  { 362, -1, -1, sizeof(::grpc::NoActiveKeyForRecipientEvent)},
  { 369, -1, -1, sizeof(::grpc::AddressChangedEvent)},
  { 376, -1, -1, sizeof(::grpc::AddressChangedLogoutEvent)},
  { 383, -1, -1, sizeof(::grpc::ApiCertIssueEvent)},
  { 389, -1, -1, sizeof(::grpc::UserEvent)},
  { 399, -1, -1, sizeof(::grpc::ToggleSplitModeFinishedEvent)},
  { 406, -1, -1, sizeof(::grpc::UserDisconnectedEvent)},
  { 413, -1, -1, sizeof(::grpc::UserChangedEvent)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_PointResponse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ReportBugRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginAbortRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ChangeLocalCacheRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ChangePortsRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_AvailableKeychainsResponse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_User_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UserSplitModeRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UserListResponse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ConfigureAppleMailRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_StreamEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_AppEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_InternetStatusEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_AutostartFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ResetFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ReportBugFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ReportBugSuccessEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ReportBugErrorEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ShowMainWindowEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginErrorEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginTfaRequestedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginTwoPasswordsRequestedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_LoginFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateErrorEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateManualReadyEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateManualRestartNeededEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateForceEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateSilentRestartNeeded_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateIsLatestVersion_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UpdateCheckFinished_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_CacheEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_CacheErrorEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_CacheLocationChangeSuccessEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ChangeLocalCacheFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_MailSettingsEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_MailSettingsErrorEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UseSslForSmtpFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ChangePortsFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_KeychainEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ChangeKeychainFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_HasNoKeychainEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_RebuildKeychainEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_MailEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_NoActiveKeyForRecipientEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_AddressChangedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_AddressChangedLogoutEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ApiCertIssueEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UserEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_ToggleSplitModeFinishedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UserDisconnectedEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::grpc::_UserChangedEvent_default_instance_),
};

const char descriptor_table_protodef_bridge_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\014bridge.proto\022\004grpc\032\033google/protobuf/em"
  "pty.proto\032\036google/protobuf/wrappers.prot"
  "o\"%\n\rPointResponse\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005"
  "\"b\n\020ReportBugRequest\022\023\n\013description\030\001 \001("
  "\t\022\017\n\007address\030\002 \001(\t\022\023\n\013emailClient\030\003 \001(\t\022"
  "\023\n\013includeLogs\030\004 \001(\010\"2\n\014LoginRequest\022\020\n\010"
  "username\030\001 \001(\t\022\020\n\010password\030\002 \001(\t\"%\n\021Logi"
  "nAbortRequest\022\020\n\010username\030\001 \001(\t\"I\n\027Chang"
  "eLocalCacheRequest\022\027\n\017enableDiskCache\030\001 "
  "\001(\010\022\025\n\rdiskCachePath\030\002 \001(\t\"8\n\022ChangePort"
  "sRequest\022\020\n\010imapPort\030\001 \001(\005\022\020\n\010smtpPort\030\002"
  " \001(\005\"/\n\032AvailableKeychainsResponse\022\021\n\tke"
  "ychains\030\001 \003(\t\"\301\001\n\004User\022\n\n\002id\030\001 \001(\t\022\020\n\010us"
  "ername\030\002 \001(\t\022\022\n\navatarText\030\003 \001(\t\022\020\n\010logg"
  "edIn\030\004 \001(\010\022\021\n\tsplitMode\030\005 \001(\010\022\026\n\016setupGu"
  "ideSeen\030\006 \001(\010\022\021\n\tusedBytes\030\007 \001(\003\022\022\n\ntota"
  "lBytes\030\010 \001(\003\022\020\n\010password\030\t \001(\t\022\021\n\taddres"
  "ses\030\n \003(\t\"6\n\024UserSplitModeRequest\022\016\n\006use"
  "rID\030\001 \001(\t\022\016\n\006active\030\002 \001(\010\"-\n\020UserListRes"
  "ponse\022\031\n\005users\030\001 \003(\0132\n.grpc.User\"<\n\031Conf"
  "igureAppleMailRequest\022\016\n\006userID\030\001 \001(\t\022\017\n"
  "\007address\030\002 \001(\t\"\274\002\n\013StreamEvent\022\035\n\003app\030\001 "
  "\001(\0132\016.grpc.AppEventH\000\022!\n\005login\030\002 \001(\0132\020.g"
  "rpc.LoginEventH\000\022#\n\006update\030\003 \001(\0132\021.grpc."
  "UpdateEventH\000\022!\n\005cache\030\004 \001(\0132\020.grpc.Cach"
  "eEventH\000\022/\n\014mailSettings\030\005 \001(\0132\027.grpc.Ma"
  "ilSettingsEventH\000\022\'\n\010keychain\030\006 \001(\0132\023.gr"
  "pc.KeychainEventH\000\022\037\n\004mail\030\007 \001(\0132\017.grpc."
  "MailEventH\000\022\037\n\004user\030\010 \001(\0132\017.grpc.UserEve"
  "ntH\000B\007\n\005event\"\224\003\n\010AppEvent\0223\n\016internetSt"
  "atus\030\001 \001(\0132\031.grpc.InternetStatusEventH\000\022"
  "9\n\021autostartFinished\030\002 \001(\0132\034.grpc.Autost"
  "artFinishedEventH\000\0221\n\rresetFinished\030\003 \001("
  "\0132\030.grpc.ResetFinishedEventH\000\0229\n\021reportB"
  "ugFinished\030\004 \001(\0132\034.grpc.ReportBugFinishe"
  "dEventH\000\0227\n\020reportBugSuccess\030\005 \001(\0132\033.grp"
  "c.ReportBugSuccessEventH\000\0223\n\016reportBugEr"
  "ror\030\006 \001(\0132\031.grpc.ReportBugErrorEventH\000\0223"
  "\n\016showMainWindow\030\007 \001(\0132\031.grpc.ShowMainWi"
  "ndowEventH\000B\007\n\005event\"(\n\023InternetStatusEv"
  "ent\022\021\n\tconnected\030\001 \001(\010\"\030\n\026AutostartFinis"
  "hedEvent\"\024\n\022ResetFinishedEvent\"\030\n\026Report"
  "BugFinishedEvent\"\027\n\025ReportBugSuccessEven"
  "t\"\025\n\023ReportBugErrorEvent\"\025\n\023ShowMainWind"
  "owEvent\"\350\001\n\nLoginEvent\022&\n\005error\030\001 \001(\0132\025."
  "grpc.LoginErrorEventH\000\0224\n\014tfaRequested\030\002"
  " \001(\0132\034.grpc.LoginTfaRequestedEventH\000\022E\n\024"
  "twoPasswordRequested\030\003 \001(\0132%.grpc.LoginT"
  "woPasswordsRequestedEventH\000\022,\n\010finished\030"
  "\004 \001(\0132\030.grpc.LoginFinishedEventH\000B\007\n\005eve"
  "nt\"F\n\017LoginErrorEvent\022\"\n\004type\030\001 \001(\0162\024.gr"
  "pc.LoginErrorType\022\017\n\007message\030\002 \001(\t\"*\n\026Lo"
  "ginTfaRequestedEvent\022\020\n\010username\030\001 \001(\t\"!"
  "\n\037LoginTwoPasswordsRequestedEvent\"0\n\022Log"
  "inFinishedEvent\022\032\n\022wasAlreadyLoggedIn\030\001 "
  "\001(\010\"\216\003\n\013UpdateEvent\022\'\n\005error\030\001 \001(\0132\026.grp"
  "c.UpdateErrorEventH\000\0223\n\013manualReady\030\002 \001("
  "\0132\034.grpc.UpdateManualReadyEventH\000\022C\n\023man"
  "ualRestartNeeded\030\003 \001(\0132$.grpc.UpdateManu"
  "alRestartNeededEventH\000\022\'\n\005force\030\004 \001(\0132\026."
  "grpc.UpdateForceEventH\000\022>\n\023silentRestart"
  "Needed\030\005 \001(\0132\037.grpc.UpdateSilentRestartN"
  "eededH\000\0226\n\017isLatestVersion\030\006 \001(\0132\033.grpc."
  "UpdateIsLatestVersionH\000\0222\n\rcheckFinished"
  "\030\007 \001(\0132\031.grpc.UpdateCheckFinishedH\000B\007\n\005e"
  "vent\"7\n\020UpdateErrorEvent\022#\n\004type\030\001 \001(\0162\025"
  ".grpc.UpdateErrorType\")\n\026UpdateManualRea"
  "dyEvent\022\017\n\007version\030\001 \001(\t\" \n\036UpdateManual"
  "RestartNeededEvent\"#\n\020UpdateForceEvent\022\017"
  "\n\007version\030\001 \001(\t\"\033\n\031UpdateSilentRestartNe"
  "eded\"\027\n\025UpdateIsLatestVersion\"\025\n\023UpdateC"
  "heckFinished\"\317\001\n\nCacheEvent\022&\n\005error\030\001 \001"
  "(\0132\025.grpc.CacheErrorEventH\000\022G\n\026locationC"
  "hangedSuccess\030\002 \001(\0132%.grpc.CacheLocation"
  "ChangeSuccessEventH\000\022G\n\030changeLocalCache"
  "Finished\030\003 \001(\0132#.grpc.ChangeLocalCacheFi"
  "nishedEventH\000B\007\n\005event\"5\n\017CacheErrorEven"
  "t\022\"\n\004type\030\001 \001(\0162\024.grpc.CacheErrorType\"!\n"
  "\037CacheLocationChangeSuccessEvent\"\037\n\035Chan"
  "geLocalCacheFinishedEvent\"\315\001\n\021MailSettin"
  "gsEvent\022-\n\005error\030\001 \001(\0132\034.grpc.MailSettin"
  "gsErrorEventH\000\022A\n\025useSslForSmtpFinished\030"
  "\002 \001(\0132 .grpc.UseSslForSmtpFinishedEventH"
  "\000\022=\n\023changePortsFinished\030\003 \001(\0132\036.grpc.Ch"
  "angePortsFinishedEventH\000B\007\n\005event\"C\n\026Mai"
  "lSettingsErrorEvent\022)\n\004type\030\001 \001(\0162\033.grpc"
  ".MailSettingsErrorType\"\034\n\032UseSslForSmtpF"
  "inishedEvent\"\032\n\030ChangePortsFinishedEvent"
  "\"\307\001\n\rKeychainEvent\022C\n\026changeKeychainFini"
  "shed\030\001 \001(\0132!.grpc.ChangeKeychainFinished"
  "EventH\000\0221\n\rhasNoKeychain\030\002 \001(\0132\030.grpc.Ha"
  "sNoKeychainEventH\000\0225\n\017rebuildKeychain\030\003 "
  "\001(\0132\032.grpc.RebuildKeychainEventH\000B\007\n\005eve"
  "nt\"\035\n\033ChangeKeychainFinishedEvent\"\024\n\022Has"
  "NoKeychainEvent\"\026\n\024RebuildKeychainEvent\""
  "\207\002\n\tMailEvent\022J\n\034noActiveKeyForRecipient"
  "Event\030\001 \001(\0132\".grpc.NoActiveKeyForRecipie"
  "ntEventH\000\0223\n\016addressChanged\030\002 \001(\0132\031.grpc"
  ".AddressChangedEventH\000\022\?\n\024addressChanged"
  "Logout\030\003 \001(\0132\037.grpc.AddressChangedLogout"
  "EventH\000\022/\n\014apiCertIssue\030\006 \001(\0132\027.grpc.Api"
  "CertIssueEventH\000B\007\n\005event\"-\n\034NoActiveKey"
  "ForRecipientEvent\022\r\n\005email\030\001 \001(\t\"&\n\023Addr"
  "essChangedEvent\022\017\n\007address\030\001 \001(\t\",\n\031Addr"
  "essChangedLogoutEvent\022\017\n\007address\030\001 \001(\t\"\023"
  "\n\021ApiCertIssueEvent\"\303\001\n\tUserEvent\022E\n\027tog"
  "gleSplitModeFinished\030\001 \001(\0132\".grpc.Toggle"
  "SplitModeFinishedEventH\000\0227\n\020userDisconne"
  "cted\030\002 \001(\0132\033.grpc.UserDisconnectedEventH"
  "\000\022-\n\013userChanged\030\003 \001(\0132\026.grpc.UserChange"
  "dEventH\000B\007\n\005event\".\n\034ToggleSplitModeFini"
  "shedEvent\022\016\n\006userID\030\001 \001(\t\")\n\025UserDisconn"
  "ectedEvent\022\020\n\010username\030\001 \001(\t\",\n\020UserChan"
  "gedEvent\022\030\n\004user\030\001 \001(\0132\n.grpc.User*\242\001\n\016L"
  "oginErrorType\022\033\n\027USERNAME_PASSWORD_ERROR"
  "\020\000\022\r\n\tFREE_USER\020\001\022\024\n\020CONNECTION_ERROR\020\002\022"
  "\r\n\tTFA_ERROR\020\003\022\r\n\tTFA_ABORT\020\004\022\027\n\023TWO_PAS"
  "SWORDS_ERROR\020\005\022\027\n\023TWO_PASSWORDS_ABORT\020\006*"
  "[\n\017UpdateErrorType\022\027\n\023UPDATE_MANUAL_ERRO"
  "R\020\000\022\026\n\022UPDATE_FORCE_ERROR\020\001\022\027\n\023UPDATE_SI"
  "LENT_ERROR\020\002*W\n\016CacheErrorType\022\033\n\027CACHE_"
  "UNAVAILABLE_ERROR\020\000\022\031\n\025CACHE_CANT_MOVE_E"
  "RROR\020\001\022\r\n\tDISK_FULL\020\002*A\n\025MailSettingsErr"
  "orType\022\023\n\017IMAP_PORT_ISSUE\020\000\022\023\n\017SMTP_PORT"
  "_ISSUE\020\0012\254!\n\006Bridge\022;\n\014GetCursorPos\022\026.go"
  "ogle.protobuf.Empty\032\023.grpc.PointResponse"
  "\022:\n\010GuiReady\022\026.google.protobuf.Empty\032\026.g"
  "oogle.protobuf.Empty\0226\n\004Quit\022\026.google.pr"
  "otobuf.Empty\032\026.google.protobuf.Empty\0229\n\007"
  "Restart\022\026.google.protobuf.Empty\032\026.google"
  ".protobuf.Empty\022F\n\020SetShowOnStartup\022\032.go"
  "ogle.protobuf.BoolValue\032\026.google.protobu"
  "f.Empty\022C\n\rShowOnStartup\022\026.google.protob"
  "uf.Empty\032\032.google.protobuf.BoolValue\022I\n\023"
  "SetShowSplashScreen\022\032.google.protobuf.Bo"
  "olValue\032\026.google.protobuf.Empty\022F\n\020ShowS"
  "plashScreen\022\026.google.protobuf.Empty\032\032.go"
  "ogle.protobuf.BoolValue\022H\n\022SetDockIconVi"
  "sible\022\032.google.protobuf.BoolValue\032\026.goog"
  "le.protobuf.Empty\022E\n\017DockIconVisible\022\026.g"
  "oogle.protobuf.Empty\032\032.google.protobuf.B"
  "oolValue\022H\n\022SetIsFirstGuiStart\022\032.google."
  "protobuf.BoolValue\032\026.google.protobuf.Emp"
  "ty\022E\n\017IsFirstGuiStart\022\026.google.protobuf."
  "Empty\032\032.google.protobuf.BoolValue\022F\n\020Set"
  "IsAutostartOn\022\032.google.protobuf.BoolValu"
  "e\032\026.google.protobuf.Empty\022C\n\rIsAutostart"
  "On\022\026.google.protobuf.Empty\032\032.google.prot"
  "obuf.BoolValue\022F\n\020SetIsBetaEnabled\022\032.goo"
  "gle.protobuf.BoolValue\032\026.google.protobuf"
  ".Empty\022C\n\rIsBetaEnabled\022\026.google.protobu"
  "f.Empty\032\032.google.protobuf.BoolValue\022<\n\004G"
  "oOs\022\026.google.protobuf.Empty\032\034.google.pro"
  "tobuf.StringValue\022>\n\014TriggerReset\022\026.goog"
  "le.protobuf.Empty\032\026.google.protobuf.Empt"
  "y\022\?\n\007Version\022\026.google.protobuf.Empty\032\034.g"
  "oogle.protobuf.StringValue\022\?\n\007LogPath\022\026."
  "google.protobuf.Empty\032\034.google.protobuf."
  "StringValue\022C\n\013LicensePath\022\026.google.prot"
  "obuf.Empty\032\034.google.protobuf.StringValue"
  "\022H\n\020ReleaseNotesLink\022\026.google.protobuf.E"
  "mpty\032\034.google.protobuf.StringValue\022G\n\017La"
  "ndingPageLink\022\026.google.protobuf.Empty\032\034."
  "google.protobuf.StringValue\022J\n\022SetColorS"
  "chemeName\022\034.google.protobuf.StringValue\032"
  "\026.google.protobuf.Empty\022G\n\017ColorSchemeNa"
  "me\022\026.google.protobuf.Empty\032\034.google.prot"
  "obuf.StringValue\022M\n\025SetCurrentEmailClien"
  "t\022\034.google.protobuf.StringValue\032\026.google"
  ".protobuf.Empty\022J\n\022CurrentEmailClient\022\026."
  "google.protobuf.Empty\032\034.google.protobuf."
  "StringValue\022;\n\tReportBug\022\026.grpc.ReportBu"
  "gRequest\032\026.google.protobuf.Empty\0223\n\005Logi"
  "n\022\022.grpc.LoginRequest\032\026.google.protobuf."
  "Empty\0226\n\010Login2FA\022\022.grpc.LoginRequest\032\026."
  "google.protobuf.Empty\022=\n\017Login2Passwords"
  "\022\022.grpc.LoginRequest\032\026.google.protobuf.E"
  "mpty\022=\n\nLoginAbort\022\027.grpc.LoginAbortRequ"
  "est\032\026.google.protobuf.Empty\022=\n\013CheckUpda"
  "te\022\026.google.protobuf.Empty\032\026.google.prot"
  "obuf.Empty\022\?\n\rInstallUpdate\022\026.google.pro"
  "tobuf.Empty\032\026.google.protobuf.Empty\022L\n\026S"
  "etIsAutomaticUpdateOn\022\032.google.protobuf."
  "BoolValue\032\026.google.protobuf.Empty\022I\n\023IsA"
  "utomaticUpdateOn\022\026.google.protobuf.Empty"
  "\032\032.google.protobuf.BoolValue\022M\n\027SetIsCac"
  "heOnDiskEnabled\022\032.google.protobuf.BoolVa"
  "lue\032\026.google.protobuf.Empty\022J\n\024IsCacheOn"
  "DiskEnabled\022\026.google.protobuf.Empty\032\032.go"
  "ogle.protobuf.BoolValue\022H\n\020SetDiskCacheP"
  "ath\022\034.google.protobuf.StringValue\032\026.goog"
  "le.protobuf.Empty\022E\n\rDiskCachePath\022\026.goo"
  "gle.protobuf.Empty\032\034.google.protobuf.Str"
  "ingValue\022I\n\020ChangeLocalCache\022\035.grpc.Chan"
  "geLocalCacheRequest\032\026.google.protobuf.Em"
  "pty\022E\n\017SetIsDoHEnabled\022\032.google.protobuf"
  ".BoolValue\032\026.google.protobuf.Empty\022B\n\014Is"
  "DoHEnabled\022\026.google.protobuf.Empty\032\032.goo"
  "gle.protobuf.BoolValue\022F\n\020SetUseSslForSm"
  "tp\022\032.google.protobuf.BoolValue\032\026.google."
  "protobuf.Empty\022C\n\rUseSslForSmtp\022\026.google"
  ".protobuf.Empty\032\032.google.protobuf.BoolVa"
  "lue\022@\n\010Hostname\022\026.google.protobuf.Empty\032"
  "\034.google.protobuf.StringValue\022B\n\013SetImap"
  "Port\022\033.google.protobuf.Int32Value\032\026.goog"
  "le.protobuf.Empty\022\?\n\010ImapPort\022\026.google.p"
  "rotobuf.Empty\032\033.google.protobuf.Int32Val"
  "ue\022B\n\013SetSmtpPort\022\033.google.protobuf.Int3"
  "2Value\032\026.google.protobuf.Empty\022\?\n\010SmtpPo"
  "rt\022\026.google.protobuf.Empty\032\033.google.prot"
  "obuf.Int32Value\022\?\n\013ChangePorts\022\030.grpc.Ch"
  "angePortsRequest\032\026.google.protobuf.Empty"
  "\022E\n\nIsPortFree\022\033.google.protobuf.Int32Va"
  "lue\032\032.google.protobuf.BoolValue\022N\n\022Avail"
  "ableKeychains\022\026.google.protobuf.Empty\032 ."
  "grpc.AvailableKeychainsResponse\022J\n\022SetCu"
  "rrentKeychain\022\034.google.protobuf.StringVa"
  "lue\032\026.google.protobuf.Empty\022G\n\017CurrentKe"
  "ychain\022\026.google.protobuf.Empty\032\034.google."
  "protobuf.StringValue\022=\n\013GetUserList\022\026.go"
  "ogle.protobuf.Empty\032\026.grpc.UserListRespo"
  "nse\022-\n\007GetUser\022\026.google.protobuf.Empty\032\n"
  ".grpc.User\022F\n\020SetUserSplitMode\022\032.grpc.Us"
  "erSplitModeRequest\032\026.google.protobuf.Emp"
  "ty\022B\n\nLogoutUser\022\034.google.protobuf.Strin"
  "gValue\032\026.google.protobuf.Empty\022B\n\nRemove"
  "User\022\034.google.protobuf.StringValue\032\026.goo"
  "gle.protobuf.Empty\022Q\n\026ConfigureUserApple"
  "Mail\022\037.grpc.ConfigureAppleMailRequest\032\026."
  "google.protobuf.Empty\0228\n\tGetEvents\022\026.goo"
  "gle.protobuf.Empty\032\021.grpc.StreamEvent0\001B"
  "3Z1github.com/ProtonMail/proton-bridge/i"
  "nternal/grpcb\006proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_bridge_2eproto_deps[2] = {
  &::descriptor_table_google_2fprotobuf_2fempty_2eproto,
  &::descriptor_table_google_2fprotobuf_2fwrappers_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_bridge_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_bridge_2eproto = {
  false, false, 9300, descriptor_table_protodef_bridge_2eproto, "bridge.proto", 
  &descriptor_table_bridge_2eproto_once, descriptor_table_bridge_2eproto_deps, 2, 54,
  schemas, file_default_instances, TableStruct_bridge_2eproto::offsets,
  file_level_metadata_bridge_2eproto, file_level_enum_descriptors_bridge_2eproto, file_level_service_descriptors_bridge_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_bridge_2eproto_getter() {
  return &descriptor_table_bridge_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_bridge_2eproto(&descriptor_table_bridge_2eproto);
namespace grpc {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LoginErrorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bridge_2eproto);
  return file_level_enum_descriptors_bridge_2eproto[0];
}
bool LoginErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UpdateErrorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bridge_2eproto);
  return file_level_enum_descriptors_bridge_2eproto[1];
}
bool UpdateErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CacheErrorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bridge_2eproto);
  return file_level_enum_descriptors_bridge_2eproto[2];
}
bool CacheErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MailSettingsErrorType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bridge_2eproto);
  return file_level_enum_descriptors_bridge_2eproto[3];
}
bool MailSettingsErrorType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

class PointResponse::_Internal {
 public:
};

PointResponse::PointResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.PointResponse)
}
PointResponse::PointResponse(const PointResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&y_) -
    reinterpret_cast<char*>(&x_)) + sizeof(y_));
  // @@protoc_insertion_point(copy_constructor:grpc.PointResponse)
}

inline void PointResponse::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&y_) -
    reinterpret_cast<char*>(&x_)) + sizeof(y_));
}

PointResponse::~PointResponse() {
  // @@protoc_insertion_point(destructor:grpc.PointResponse)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void PointResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void PointResponse::ArenaDtor(void* object) {
  PointResponse* _this = reinterpret_cast< PointResponse* >(object);
  (void)_this;
}
void PointResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void PointResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void PointResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.PointResponse)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&y_) -
      reinterpret_cast<char*>(&x_)) + sizeof(y_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PointResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 x = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 y = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* PointResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.PointResponse)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 x = 1;
  if (this->_internal_x() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target);
  }

  // int32 y = 2;
  if (this->_internal_y() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.PointResponse)
  return target;
}

size_t PointResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.PointResponse)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 x = 1;
  if (this->_internal_x() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_x());
  }

  // int32 y = 2;
  if (this->_internal_y() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_y());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PointResponse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    PointResponse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PointResponse::GetClassData() const { return &_class_data_; }

void PointResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<PointResponse *>(to)->MergeFrom(
      static_cast<const PointResponse &>(from));
}


void PointResponse::MergeFrom(const PointResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.PointResponse)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_x() != 0) {
    _internal_set_x(from._internal_x());
  }
  if (from._internal_y() != 0) {
    _internal_set_y(from._internal_y());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void PointResponse::CopyFrom(const PointResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.PointResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PointResponse::IsInitialized() const {
  return true;
}

void PointResponse::InternalSwap(PointResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(PointResponse, y_)
      + sizeof(PointResponse::y_)
      - PROTOBUF_FIELD_OFFSET(PointResponse, x_)>(
          reinterpret_cast<char*>(&x_),
          reinterpret_cast<char*>(&other->x_));
}

::PROTOBUF_NAMESPACE_ID::Metadata PointResponse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[0]);
}

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

class ReportBugRequest::_Internal {
 public:
};

ReportBugRequest::ReportBugRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.ReportBugRequest)
}
ReportBugRequest::ReportBugRequest(const ReportBugRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_description().empty()) {
    description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_description(), 
      GetArenaForAllocation());
  }
  address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_address().empty()) {
    address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_address(), 
      GetArenaForAllocation());
  }
  emailclient_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    emailclient_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_emailclient().empty()) {
    emailclient_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_emailclient(), 
      GetArenaForAllocation());
  }
  includelogs_ = from.includelogs_;
  // @@protoc_insertion_point(copy_constructor:grpc.ReportBugRequest)
}

inline void ReportBugRequest::SharedCtor() {
description_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
emailclient_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  emailclient_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
includelogs_ = false;
}

ReportBugRequest::~ReportBugRequest() {
  // @@protoc_insertion_point(destructor:grpc.ReportBugRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ReportBugRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  description_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  emailclient_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ReportBugRequest::ArenaDtor(void* object) {
  ReportBugRequest* _this = reinterpret_cast< ReportBugRequest* >(object);
  (void)_this;
}
void ReportBugRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ReportBugRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ReportBugRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.ReportBugRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  description_.ClearToEmpty();
  address_.ClearToEmpty();
  emailclient_.ClearToEmpty();
  includelogs_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ReportBugRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string description = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_description();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ReportBugRequest.description"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string address = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ReportBugRequest.address"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string emailClient = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_emailclient();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ReportBugRequest.emailClient"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool includeLogs = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          includelogs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ReportBugRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.ReportBugRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string description = 1;
  if (!this->_internal_description().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ReportBugRequest.description");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_description(), target);
  }

  // string address = 2;
  if (!this->_internal_address().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_address().data(), static_cast<int>(this->_internal_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ReportBugRequest.address");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_address(), target);
  }

  // string emailClient = 3;
  if (!this->_internal_emailclient().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_emailclient().data(), static_cast<int>(this->_internal_emailclient().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ReportBugRequest.emailClient");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_emailclient(), target);
  }

  // bool includeLogs = 4;
  if (this->_internal_includelogs() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_includelogs(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.ReportBugRequest)
  return target;
}

size_t ReportBugRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.ReportBugRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string description = 1;
  if (!this->_internal_description().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_description());
  }

  // string address = 2;
  if (!this->_internal_address().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_address());
  }

  // string emailClient = 3;
  if (!this->_internal_emailclient().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_emailclient());
  }

  // bool includeLogs = 4;
  if (this->_internal_includelogs() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReportBugRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ReportBugRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReportBugRequest::GetClassData() const { return &_class_data_; }

void ReportBugRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ReportBugRequest *>(to)->MergeFrom(
      static_cast<const ReportBugRequest &>(from));
}


void ReportBugRequest::MergeFrom(const ReportBugRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.ReportBugRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_description().empty()) {
    _internal_set_description(from._internal_description());
  }
  if (!from._internal_address().empty()) {
    _internal_set_address(from._internal_address());
  }
  if (!from._internal_emailclient().empty()) {
    _internal_set_emailclient(from._internal_emailclient());
  }
  if (from._internal_includelogs() != 0) {
    _internal_set_includelogs(from._internal_includelogs());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ReportBugRequest::CopyFrom(const ReportBugRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.ReportBugRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ReportBugRequest::IsInitialized() const {
  return true;
}

void ReportBugRequest::InternalSwap(ReportBugRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &description_, lhs_arena,
      &other->description_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &address_, lhs_arena,
      &other->address_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &emailclient_, lhs_arena,
      &other->emailclient_, rhs_arena
  );
  swap(includelogs_, other->includelogs_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ReportBugRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[1]);
}

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

class LoginRequest::_Internal {
 public:
};

LoginRequest::LoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginRequest)
}
LoginRequest::LoginRequest(const LoginRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(), 
      GetArenaForAllocation());
  }
  password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.LoginRequest)
}

inline void LoginRequest::SharedCtor() {
username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

LoginRequest::~LoginRequest() {
  // @@protoc_insertion_point(destructor:grpc.LoginRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void LoginRequest::ArenaDtor(void* object) {
  LoginRequest* _this = reinterpret_cast< LoginRequest* >(object);
  (void)_this;
}
void LoginRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  username_.ClearToEmpty();
  password_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.LoginRequest.username"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string password = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_password();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.LoginRequest.password"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.LoginRequest.username");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_username(), target);
  }

  // string password = 2;
  if (!this->_internal_password().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_password().data(), static_cast<int>(this->_internal_password().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.LoginRequest.password");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_password(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginRequest)
  return target;
}

size_t LoginRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_username());
  }

  // string password = 2;
  if (!this->_internal_password().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_password());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginRequest::GetClassData() const { return &_class_data_; }

void LoginRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginRequest *>(to)->MergeFrom(
      static_cast<const LoginRequest &>(from));
}


void LoginRequest::MergeFrom(const LoginRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_username().empty()) {
    _internal_set_username(from._internal_username());
  }
  if (!from._internal_password().empty()) {
    _internal_set_password(from._internal_password());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginRequest::CopyFrom(const LoginRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginRequest::IsInitialized() const {
  return true;
}

void LoginRequest::InternalSwap(LoginRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &username_, lhs_arena,
      &other->username_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &password_, lhs_arena,
      &other->password_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[2]);
}

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

class LoginAbortRequest::_Internal {
 public:
};

LoginAbortRequest::LoginAbortRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginAbortRequest)
}
LoginAbortRequest::LoginAbortRequest(const LoginAbortRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.LoginAbortRequest)
}

inline void LoginAbortRequest::SharedCtor() {
username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

LoginAbortRequest::~LoginAbortRequest() {
  // @@protoc_insertion_point(destructor:grpc.LoginAbortRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginAbortRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void LoginAbortRequest::ArenaDtor(void* object) {
  LoginAbortRequest* _this = reinterpret_cast< LoginAbortRequest* >(object);
  (void)_this;
}
void LoginAbortRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginAbortRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginAbortRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginAbortRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  username_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginAbortRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.LoginAbortRequest.username"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginAbortRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginAbortRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.LoginAbortRequest.username");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_username(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginAbortRequest)
  return target;
}

size_t LoginAbortRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginAbortRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_username());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginAbortRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginAbortRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginAbortRequest::GetClassData() const { return &_class_data_; }

void LoginAbortRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginAbortRequest *>(to)->MergeFrom(
      static_cast<const LoginAbortRequest &>(from));
}


void LoginAbortRequest::MergeFrom(const LoginAbortRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginAbortRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_username().empty()) {
    _internal_set_username(from._internal_username());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginAbortRequest::CopyFrom(const LoginAbortRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginAbortRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginAbortRequest::IsInitialized() const {
  return true;
}

void LoginAbortRequest::InternalSwap(LoginAbortRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &username_, lhs_arena,
      &other->username_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginAbortRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[3]);
}

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

class ChangeLocalCacheRequest::_Internal {
 public:
};

ChangeLocalCacheRequest::ChangeLocalCacheRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.ChangeLocalCacheRequest)
}
ChangeLocalCacheRequest::ChangeLocalCacheRequest(const ChangeLocalCacheRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  diskcachepath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    diskcachepath_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_diskcachepath().empty()) {
    diskcachepath_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_diskcachepath(), 
      GetArenaForAllocation());
  }
  enablediskcache_ = from.enablediskcache_;
  // @@protoc_insertion_point(copy_constructor:grpc.ChangeLocalCacheRequest)
}

inline void ChangeLocalCacheRequest::SharedCtor() {
diskcachepath_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  diskcachepath_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
enablediskcache_ = false;
}

ChangeLocalCacheRequest::~ChangeLocalCacheRequest() {
  // @@protoc_insertion_point(destructor:grpc.ChangeLocalCacheRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ChangeLocalCacheRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  diskcachepath_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ChangeLocalCacheRequest::ArenaDtor(void* object) {
  ChangeLocalCacheRequest* _this = reinterpret_cast< ChangeLocalCacheRequest* >(object);
  (void)_this;
}
void ChangeLocalCacheRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ChangeLocalCacheRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ChangeLocalCacheRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.ChangeLocalCacheRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  diskcachepath_.ClearToEmpty();
  enablediskcache_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ChangeLocalCacheRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool enableDiskCache = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          enablediskcache_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string diskCachePath = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_diskcachepath();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ChangeLocalCacheRequest.diskCachePath"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ChangeLocalCacheRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.ChangeLocalCacheRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool enableDiskCache = 1;
  if (this->_internal_enablediskcache() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_enablediskcache(), target);
  }

  // string diskCachePath = 2;
  if (!this->_internal_diskcachepath().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_diskcachepath().data(), static_cast<int>(this->_internal_diskcachepath().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ChangeLocalCacheRequest.diskCachePath");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_diskcachepath(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.ChangeLocalCacheRequest)
  return target;
}

size_t ChangeLocalCacheRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.ChangeLocalCacheRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string diskCachePath = 2;
  if (!this->_internal_diskcachepath().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_diskcachepath());
  }

  // bool enableDiskCache = 1;
  if (this->_internal_enablediskcache() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChangeLocalCacheRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ChangeLocalCacheRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChangeLocalCacheRequest::GetClassData() const { return &_class_data_; }

void ChangeLocalCacheRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ChangeLocalCacheRequest *>(to)->MergeFrom(
      static_cast<const ChangeLocalCacheRequest &>(from));
}


void ChangeLocalCacheRequest::MergeFrom(const ChangeLocalCacheRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.ChangeLocalCacheRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_diskcachepath().empty()) {
    _internal_set_diskcachepath(from._internal_diskcachepath());
  }
  if (from._internal_enablediskcache() != 0) {
    _internal_set_enablediskcache(from._internal_enablediskcache());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ChangeLocalCacheRequest::CopyFrom(const ChangeLocalCacheRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.ChangeLocalCacheRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChangeLocalCacheRequest::IsInitialized() const {
  return true;
}

void ChangeLocalCacheRequest::InternalSwap(ChangeLocalCacheRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &diskcachepath_, lhs_arena,
      &other->diskcachepath_, rhs_arena
  );
  swap(enablediskcache_, other->enablediskcache_);
}

::PROTOBUF_NAMESPACE_ID::Metadata ChangeLocalCacheRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[4]);
}

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

class ChangePortsRequest::_Internal {
 public:
};

ChangePortsRequest::ChangePortsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.ChangePortsRequest)
}
ChangePortsRequest::ChangePortsRequest(const ChangePortsRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&imapport_, &from.imapport_,
    static_cast<size_t>(reinterpret_cast<char*>(&smtpport_) -
    reinterpret_cast<char*>(&imapport_)) + sizeof(smtpport_));
  // @@protoc_insertion_point(copy_constructor:grpc.ChangePortsRequest)
}

inline void ChangePortsRequest::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&imapport_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&smtpport_) -
    reinterpret_cast<char*>(&imapport_)) + sizeof(smtpport_));
}

ChangePortsRequest::~ChangePortsRequest() {
  // @@protoc_insertion_point(destructor:grpc.ChangePortsRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ChangePortsRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void ChangePortsRequest::ArenaDtor(void* object) {
  ChangePortsRequest* _this = reinterpret_cast< ChangePortsRequest* >(object);
  (void)_this;
}
void ChangePortsRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ChangePortsRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ChangePortsRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.ChangePortsRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&imapport_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&smtpport_) -
      reinterpret_cast<char*>(&imapport_)) + sizeof(smtpport_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ChangePortsRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 imapPort = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          imapport_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int32 smtpPort = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          smtpport_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ChangePortsRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.ChangePortsRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 imapPort = 1;
  if (this->_internal_imapport() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_imapport(), target);
  }

  // int32 smtpPort = 2;
  if (this->_internal_smtpport() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_smtpport(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.ChangePortsRequest)
  return target;
}

size_t ChangePortsRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.ChangePortsRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 imapPort = 1;
  if (this->_internal_imapport() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_imapport());
  }

  // int32 smtpPort = 2;
  if (this->_internal_smtpport() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_smtpport());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChangePortsRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ChangePortsRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChangePortsRequest::GetClassData() const { return &_class_data_; }

void ChangePortsRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ChangePortsRequest *>(to)->MergeFrom(
      static_cast<const ChangePortsRequest &>(from));
}


void ChangePortsRequest::MergeFrom(const ChangePortsRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.ChangePortsRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_imapport() != 0) {
    _internal_set_imapport(from._internal_imapport());
  }
  if (from._internal_smtpport() != 0) {
    _internal_set_smtpport(from._internal_smtpport());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ChangePortsRequest::CopyFrom(const ChangePortsRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.ChangePortsRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ChangePortsRequest::IsInitialized() const {
  return true;
}

void ChangePortsRequest::InternalSwap(ChangePortsRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ChangePortsRequest, smtpport_)
      + sizeof(ChangePortsRequest::smtpport_)
      - PROTOBUF_FIELD_OFFSET(ChangePortsRequest, imapport_)>(
          reinterpret_cast<char*>(&imapport_),
          reinterpret_cast<char*>(&other->imapport_));
}

::PROTOBUF_NAMESPACE_ID::Metadata ChangePortsRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[5]);
}

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

class AvailableKeychainsResponse::_Internal {
 public:
};

AvailableKeychainsResponse::AvailableKeychainsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  keychains_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.AvailableKeychainsResponse)
}
AvailableKeychainsResponse::AvailableKeychainsResponse(const AvailableKeychainsResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      keychains_(from.keychains_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.AvailableKeychainsResponse)
}

inline void AvailableKeychainsResponse::SharedCtor() {
}

AvailableKeychainsResponse::~AvailableKeychainsResponse() {
  // @@protoc_insertion_point(destructor:grpc.AvailableKeychainsResponse)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AvailableKeychainsResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void AvailableKeychainsResponse::ArenaDtor(void* object) {
  AvailableKeychainsResponse* _this = reinterpret_cast< AvailableKeychainsResponse* >(object);
  (void)_this;
}
void AvailableKeychainsResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AvailableKeychainsResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AvailableKeychainsResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.AvailableKeychainsResponse)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  keychains_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AvailableKeychainsResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated string keychains = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_keychains();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.AvailableKeychainsResponse.keychains"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* AvailableKeychainsResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.AvailableKeychainsResponse)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string keychains = 1;
  for (int i = 0, n = this->_internal_keychains_size(); i < n; i++) {
    const auto& s = this->_internal_keychains(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.AvailableKeychainsResponse.keychains");
    target = stream->WriteString(1, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.AvailableKeychainsResponse)
  return target;
}

size_t AvailableKeychainsResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.AvailableKeychainsResponse)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string keychains = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(keychains_.size());
  for (int i = 0, n = keychains_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      keychains_.Get(i));
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AvailableKeychainsResponse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AvailableKeychainsResponse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AvailableKeychainsResponse::GetClassData() const { return &_class_data_; }

void AvailableKeychainsResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AvailableKeychainsResponse *>(to)->MergeFrom(
      static_cast<const AvailableKeychainsResponse &>(from));
}


void AvailableKeychainsResponse::MergeFrom(const AvailableKeychainsResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.AvailableKeychainsResponse)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  keychains_.MergeFrom(from.keychains_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AvailableKeychainsResponse::CopyFrom(const AvailableKeychainsResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.AvailableKeychainsResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AvailableKeychainsResponse::IsInitialized() const {
  return true;
}

void AvailableKeychainsResponse::InternalSwap(AvailableKeychainsResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  keychains_.InternalSwap(&other->keychains_);
}

::PROTOBUF_NAMESPACE_ID::Metadata AvailableKeychainsResponse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[6]);
}

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

class User::_Internal {
 public:
};

User::User(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  addresses_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.User)
}
User::User(const User& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      addresses_(from.addresses_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_id(), 
      GetArenaForAllocation());
  }
  username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(), 
      GetArenaForAllocation());
  }
  avatartext_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    avatartext_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_avatartext().empty()) {
    avatartext_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_avatartext(), 
      GetArenaForAllocation());
  }
  password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(), 
      GetArenaForAllocation());
  }
  ::memcpy(&usedbytes_, &from.usedbytes_,
    static_cast<size_t>(reinterpret_cast<char*>(&setupguideseen_) -
    reinterpret_cast<char*>(&usedbytes_)) + sizeof(setupguideseen_));
  // @@protoc_insertion_point(copy_constructor:grpc.User)
}

inline void User::SharedCtor() {
id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
avatartext_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  avatartext_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&usedbytes_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&setupguideseen_) -
    reinterpret_cast<char*>(&usedbytes_)) + sizeof(setupguideseen_));
}

User::~User() {
  // @@protoc_insertion_point(destructor:grpc.User)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void User::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  avatartext_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void User::ArenaDtor(void* object) {
  User* _this = reinterpret_cast< User* >(object);
  (void)_this;
}
void User::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void User::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void User::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.User)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  addresses_.Clear();
  id_.ClearToEmpty();
  username_.ClearToEmpty();
  avatartext_.ClearToEmpty();
  password_.ClearToEmpty();
  ::memset(&usedbytes_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&setupguideseen_) -
      reinterpret_cast<char*>(&usedbytes_)) + sizeof(setupguideseen_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* User::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.User.id"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string username = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_username();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.User.username"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string avatarText = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_avatartext();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.User.avatarText"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool loggedIn = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          loggedin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool splitMode = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          splitmode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool setupGuideSeen = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          setupguideseen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 usedBytes = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          usedbytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // int64 totalBytes = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          totalbytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string password = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          auto str = _internal_mutable_password();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.User.password"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // repeated string addresses = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_addresses();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.User.addresses"));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* User::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.User)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1;
  if (!this->_internal_id().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_id().data(), static_cast<int>(this->_internal_id().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.User.id");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_id(), target);
  }

  // string username = 2;
  if (!this->_internal_username().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.User.username");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_username(), target);
  }

  // string avatarText = 3;
  if (!this->_internal_avatartext().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_avatartext().data(), static_cast<int>(this->_internal_avatartext().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.User.avatarText");
    target = stream->WriteStringMaybeAliased(
        3, this->_internal_avatartext(), target);
  }

  // bool loggedIn = 4;
  if (this->_internal_loggedin() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_loggedin(), target);
  }

  // bool splitMode = 5;
  if (this->_internal_splitmode() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_splitmode(), target);
  }

  // bool setupGuideSeen = 6;
  if (this->_internal_setupguideseen() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_setupguideseen(), target);
  }

  // int64 usedBytes = 7;
  if (this->_internal_usedbytes() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_usedbytes(), target);
  }

  // int64 totalBytes = 8;
  if (this->_internal_totalbytes() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->_internal_totalbytes(), target);
  }

  // string password = 9;
  if (!this->_internal_password().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_password().data(), static_cast<int>(this->_internal_password().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.User.password");
    target = stream->WriteStringMaybeAliased(
        9, this->_internal_password(), target);
  }

  // repeated string addresses = 10;
  for (int i = 0, n = this->_internal_addresses_size(); i < n; i++) {
    const auto& s = this->_internal_addresses(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.User.addresses");
    target = stream->WriteString(10, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.User)
  return target;
}

size_t User::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.User)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string addresses = 10;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(addresses_.size());
  for (int i = 0, n = addresses_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      addresses_.Get(i));
  }

  // string id = 1;
  if (!this->_internal_id().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_id());
  }

  // string username = 2;
  if (!this->_internal_username().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_username());
  }

  // string avatarText = 3;
  if (!this->_internal_avatartext().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_avatartext());
  }

  // string password = 9;
  if (!this->_internal_password().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_password());
  }

  // int64 usedBytes = 7;
  if (this->_internal_usedbytes() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_usedbytes());
  }

  // int64 totalBytes = 8;
  if (this->_internal_totalbytes() != 0) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_totalbytes());
  }

  // bool loggedIn = 4;
  if (this->_internal_loggedin() != 0) {
    total_size += 1 + 1;
  }

  // bool splitMode = 5;
  if (this->_internal_splitmode() != 0) {
    total_size += 1 + 1;
  }

  // bool setupGuideSeen = 6;
  if (this->_internal_setupguideseen() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData User::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    User::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*User::GetClassData() const { return &_class_data_; }

void User::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<User *>(to)->MergeFrom(
      static_cast<const User &>(from));
}


void User::MergeFrom(const User& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.User)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  addresses_.MergeFrom(from.addresses_);
  if (!from._internal_id().empty()) {
    _internal_set_id(from._internal_id());
  }
  if (!from._internal_username().empty()) {
    _internal_set_username(from._internal_username());
  }
  if (!from._internal_avatartext().empty()) {
    _internal_set_avatartext(from._internal_avatartext());
  }
  if (!from._internal_password().empty()) {
    _internal_set_password(from._internal_password());
  }
  if (from._internal_usedbytes() != 0) {
    _internal_set_usedbytes(from._internal_usedbytes());
  }
  if (from._internal_totalbytes() != 0) {
    _internal_set_totalbytes(from._internal_totalbytes());
  }
  if (from._internal_loggedin() != 0) {
    _internal_set_loggedin(from._internal_loggedin());
  }
  if (from._internal_splitmode() != 0) {
    _internal_set_splitmode(from._internal_splitmode());
  }
  if (from._internal_setupguideseen() != 0) {
    _internal_set_setupguideseen(from._internal_setupguideseen());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void User::CopyFrom(const User& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.User)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool User::IsInitialized() const {
  return true;
}

void User::InternalSwap(User* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  addresses_.InternalSwap(&other->addresses_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &id_, lhs_arena,
      &other->id_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &username_, lhs_arena,
      &other->username_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &avatartext_, lhs_arena,
      &other->avatartext_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &password_, lhs_arena,
      &other->password_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(User, setupguideseen_)
      + sizeof(User::setupguideseen_)
      - PROTOBUF_FIELD_OFFSET(User, usedbytes_)>(
          reinterpret_cast<char*>(&usedbytes_),
          reinterpret_cast<char*>(&other->usedbytes_));
}

::PROTOBUF_NAMESPACE_ID::Metadata User::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[7]);
}

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

class UserSplitModeRequest::_Internal {
 public:
};

UserSplitModeRequest::UserSplitModeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UserSplitModeRequest)
}
UserSplitModeRequest::UserSplitModeRequest(const UserSplitModeRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_userid().empty()) {
    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
      GetArenaForAllocation());
  }
  active_ = from.active_;
  // @@protoc_insertion_point(copy_constructor:grpc.UserSplitModeRequest)
}

inline void UserSplitModeRequest::SharedCtor() {
userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
active_ = false;
}

UserSplitModeRequest::~UserSplitModeRequest() {
  // @@protoc_insertion_point(destructor:grpc.UserSplitModeRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UserSplitModeRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void UserSplitModeRequest::ArenaDtor(void* object) {
  UserSplitModeRequest* _this = reinterpret_cast< UserSplitModeRequest* >(object);
  (void)_this;
}
void UserSplitModeRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UserSplitModeRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UserSplitModeRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UserSplitModeRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  userid_.ClearToEmpty();
  active_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UserSplitModeRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string userID = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_userid();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.UserSplitModeRequest.userID"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // bool active = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          active_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UserSplitModeRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UserSplitModeRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.UserSplitModeRequest.userID");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_userid(), target);
  }

  // bool active = 2;
  if (this->_internal_active() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_active(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UserSplitModeRequest)
  return target;
}

size_t UserSplitModeRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UserSplitModeRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_userid());
  }

  // bool active = 2;
  if (this->_internal_active() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserSplitModeRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UserSplitModeRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserSplitModeRequest::GetClassData() const { return &_class_data_; }

void UserSplitModeRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UserSplitModeRequest *>(to)->MergeFrom(
      static_cast<const UserSplitModeRequest &>(from));
}


void UserSplitModeRequest::MergeFrom(const UserSplitModeRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UserSplitModeRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_userid().empty()) {
    _internal_set_userid(from._internal_userid());
  }
  if (from._internal_active() != 0) {
    _internal_set_active(from._internal_active());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UserSplitModeRequest::CopyFrom(const UserSplitModeRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UserSplitModeRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserSplitModeRequest::IsInitialized() const {
  return true;
}

void UserSplitModeRequest::InternalSwap(UserSplitModeRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &userid_, lhs_arena,
      &other->userid_, rhs_arena
  );
  swap(active_, other->active_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UserSplitModeRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[8]);
}

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

class UserListResponse::_Internal {
 public:
};

UserListResponse::UserListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  users_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UserListResponse)
}
UserListResponse::UserListResponse(const UserListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      users_(from.users_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UserListResponse)
}

inline void UserListResponse::SharedCtor() {
}

UserListResponse::~UserListResponse() {
  // @@protoc_insertion_point(destructor:grpc.UserListResponse)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UserListResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void UserListResponse::ArenaDtor(void* object) {
  UserListResponse* _this = reinterpret_cast< UserListResponse* >(object);
  (void)_this;
}
void UserListResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UserListResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UserListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UserListResponse)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  users_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UserListResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated .grpc.User users = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_users(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UserListResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UserListResponse)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .grpc.User users = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_users_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_users(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UserListResponse)
  return target;
}

size_t UserListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UserListResponse)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .grpc.User users = 1;
  total_size += 1UL * this->_internal_users_size();
  for (const auto& msg : this->users_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserListResponse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UserListResponse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserListResponse::GetClassData() const { return &_class_data_; }

void UserListResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UserListResponse *>(to)->MergeFrom(
      static_cast<const UserListResponse &>(from));
}


void UserListResponse::MergeFrom(const UserListResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UserListResponse)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  users_.MergeFrom(from.users_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UserListResponse::CopyFrom(const UserListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UserListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserListResponse::IsInitialized() const {
  return true;
}

void UserListResponse::InternalSwap(UserListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  users_.InternalSwap(&other->users_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UserListResponse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[9]);
}

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

class ConfigureAppleMailRequest::_Internal {
 public:
};

ConfigureAppleMailRequest::ConfigureAppleMailRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.ConfigureAppleMailRequest)
}
ConfigureAppleMailRequest::ConfigureAppleMailRequest(const ConfigureAppleMailRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_userid().empty()) {
    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
      GetArenaForAllocation());
  }
  address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_address().empty()) {
    address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_address(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.ConfigureAppleMailRequest)
}

inline void ConfigureAppleMailRequest::SharedCtor() {
userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

ConfigureAppleMailRequest::~ConfigureAppleMailRequest() {
  // @@protoc_insertion_point(destructor:grpc.ConfigureAppleMailRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ConfigureAppleMailRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ConfigureAppleMailRequest::ArenaDtor(void* object) {
  ConfigureAppleMailRequest* _this = reinterpret_cast< ConfigureAppleMailRequest* >(object);
  (void)_this;
}
void ConfigureAppleMailRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ConfigureAppleMailRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ConfigureAppleMailRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.ConfigureAppleMailRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  userid_.ClearToEmpty();
  address_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ConfigureAppleMailRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string userID = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_userid();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ConfigureAppleMailRequest.userID"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // string address = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ConfigureAppleMailRequest.address"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ConfigureAppleMailRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.ConfigureAppleMailRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ConfigureAppleMailRequest.userID");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_userid(), target);
  }

  // string address = 2;
  if (!this->_internal_address().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_address().data(), static_cast<int>(this->_internal_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ConfigureAppleMailRequest.address");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_address(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.ConfigureAppleMailRequest)
  return target;
}

size_t ConfigureAppleMailRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.ConfigureAppleMailRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_userid());
  }

  // string address = 2;
  if (!this->_internal_address().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_address());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ConfigureAppleMailRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ConfigureAppleMailRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ConfigureAppleMailRequest::GetClassData() const { return &_class_data_; }

void ConfigureAppleMailRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ConfigureAppleMailRequest *>(to)->MergeFrom(
      static_cast<const ConfigureAppleMailRequest &>(from));
}


void ConfigureAppleMailRequest::MergeFrom(const ConfigureAppleMailRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.ConfigureAppleMailRequest)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_userid().empty()) {
    _internal_set_userid(from._internal_userid());
  }
  if (!from._internal_address().empty()) {
    _internal_set_address(from._internal_address());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ConfigureAppleMailRequest::CopyFrom(const ConfigureAppleMailRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.ConfigureAppleMailRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ConfigureAppleMailRequest::IsInitialized() const {
  return true;
}

void ConfigureAppleMailRequest::InternalSwap(ConfigureAppleMailRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &userid_, lhs_arena,
      &other->userid_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &address_, lhs_arena,
      &other->address_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata ConfigureAppleMailRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[10]);
}

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

class StreamEvent::_Internal {
 public:
  static const ::grpc::AppEvent& app(const StreamEvent* msg);
  static const ::grpc::LoginEvent& login(const StreamEvent* msg);
  static const ::grpc::UpdateEvent& update(const StreamEvent* msg);
  static const ::grpc::CacheEvent& cache(const StreamEvent* msg);
  static const ::grpc::MailSettingsEvent& mailsettings(const StreamEvent* msg);
  static const ::grpc::KeychainEvent& keychain(const StreamEvent* msg);
  static const ::grpc::MailEvent& mail(const StreamEvent* msg);
  static const ::grpc::UserEvent& user(const StreamEvent* msg);
};

const ::grpc::AppEvent&
StreamEvent::_Internal::app(const StreamEvent* msg) {
  return *msg->event_.app_;
}
const ::grpc::LoginEvent&
StreamEvent::_Internal::login(const StreamEvent* msg) {
  return *msg->event_.login_;
}
const ::grpc::UpdateEvent&
StreamEvent::_Internal::update(const StreamEvent* msg) {
  return *msg->event_.update_;
}
const ::grpc::CacheEvent&
StreamEvent::_Internal::cache(const StreamEvent* msg) {
  return *msg->event_.cache_;
}
const ::grpc::MailSettingsEvent&
StreamEvent::_Internal::mailsettings(const StreamEvent* msg) {
  return *msg->event_.mailsettings_;
}
const ::grpc::KeychainEvent&
StreamEvent::_Internal::keychain(const StreamEvent* msg) {
  return *msg->event_.keychain_;
}
const ::grpc::MailEvent&
StreamEvent::_Internal::mail(const StreamEvent* msg) {
  return *msg->event_.mail_;
}
const ::grpc::UserEvent&
StreamEvent::_Internal::user(const StreamEvent* msg) {
  return *msg->event_.user_;
}
void StreamEvent::set_allocated_app(::grpc::AppEvent* app) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (app) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::AppEvent>::GetOwningArena(app);
    if (message_arena != submessage_arena) {
      app = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, app, submessage_arena);
    }
    set_has_app();
    event_.app_ = app;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.app)
}
void StreamEvent::set_allocated_login(::grpc::LoginEvent* login) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (login) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::LoginEvent>::GetOwningArena(login);
    if (message_arena != submessage_arena) {
      login = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, login, submessage_arena);
    }
    set_has_login();
    event_.login_ = login;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.login)
}
void StreamEvent::set_allocated_update(::grpc::UpdateEvent* update) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (update) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateEvent>::GetOwningArena(update);
    if (message_arena != submessage_arena) {
      update = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, update, submessage_arena);
    }
    set_has_update();
    event_.update_ = update;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.update)
}
void StreamEvent::set_allocated_cache(::grpc::CacheEvent* cache) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (cache) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::CacheEvent>::GetOwningArena(cache);
    if (message_arena != submessage_arena) {
      cache = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cache, submessage_arena);
    }
    set_has_cache();
    event_.cache_ = cache;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.cache)
}
void StreamEvent::set_allocated_mailsettings(::grpc::MailSettingsEvent* mailsettings) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (mailsettings) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::MailSettingsEvent>::GetOwningArena(mailsettings);
    if (message_arena != submessage_arena) {
      mailsettings = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mailsettings, submessage_arena);
    }
    set_has_mailsettings();
    event_.mailsettings_ = mailsettings;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.mailSettings)
}
void StreamEvent::set_allocated_keychain(::grpc::KeychainEvent* keychain) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (keychain) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::KeychainEvent>::GetOwningArena(keychain);
    if (message_arena != submessage_arena) {
      keychain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, keychain, submessage_arena);
    }
    set_has_keychain();
    event_.keychain_ = keychain;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.keychain)
}
void StreamEvent::set_allocated_mail(::grpc::MailEvent* mail) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (mail) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::MailEvent>::GetOwningArena(mail);
    if (message_arena != submessage_arena) {
      mail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, mail, submessage_arena);
    }
    set_has_mail();
    event_.mail_ = mail;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.mail)
}
void StreamEvent::set_allocated_user(::grpc::UserEvent* user) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (user) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UserEvent>::GetOwningArena(user);
    if (message_arena != submessage_arena) {
      user = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, user, submessage_arena);
    }
    set_has_user();
    event_.user_ = user;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.StreamEvent.user)
}
StreamEvent::StreamEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.StreamEvent)
}
StreamEvent::StreamEvent(const StreamEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kApp: {
      _internal_mutable_app()->::grpc::AppEvent::MergeFrom(from._internal_app());
      break;
    }
    case kLogin: {
      _internal_mutable_login()->::grpc::LoginEvent::MergeFrom(from._internal_login());
      break;
    }
    case kUpdate: {
      _internal_mutable_update()->::grpc::UpdateEvent::MergeFrom(from._internal_update());
      break;
    }
    case kCache: {
      _internal_mutable_cache()->::grpc::CacheEvent::MergeFrom(from._internal_cache());
      break;
    }
    case kMailSettings: {
      _internal_mutable_mailsettings()->::grpc::MailSettingsEvent::MergeFrom(from._internal_mailsettings());
      break;
    }
    case kKeychain: {
      _internal_mutable_keychain()->::grpc::KeychainEvent::MergeFrom(from._internal_keychain());
      break;
    }
    case kMail: {
      _internal_mutable_mail()->::grpc::MailEvent::MergeFrom(from._internal_mail());
      break;
    }
    case kUser: {
      _internal_mutable_user()->::grpc::UserEvent::MergeFrom(from._internal_user());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.StreamEvent)
}

inline void StreamEvent::SharedCtor() {
clear_has_event();
}

StreamEvent::~StreamEvent() {
  // @@protoc_insertion_point(destructor:grpc.StreamEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void StreamEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void StreamEvent::ArenaDtor(void* object) {
  StreamEvent* _this = reinterpret_cast< StreamEvent* >(object);
  (void)_this;
}
void StreamEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void StreamEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void StreamEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.StreamEvent)
  switch (event_case()) {
    case kApp: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.app_;
      }
      break;
    }
    case kLogin: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.login_;
      }
      break;
    }
    case kUpdate: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.update_;
      }
      break;
    }
    case kCache: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.cache_;
      }
      break;
    }
    case kMailSettings: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.mailsettings_;
      }
      break;
    }
    case kKeychain: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.keychain_;
      }
      break;
    }
    case kMail: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.mail_;
      }
      break;
    }
    case kUser: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.user_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void StreamEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.StreamEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* StreamEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.AppEvent app = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_app(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.LoginEvent login = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_login(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateEvent update = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_update(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.CacheEvent cache = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_cache(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.MailSettingsEvent mailSettings = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_mailsettings(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.KeychainEvent keychain = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_keychain(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.MailEvent mail = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_mail(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UserEvent user = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_user(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* StreamEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.StreamEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.AppEvent app = 1;
  if (_internal_has_app()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::app(this), target, stream);
  }

  // .grpc.LoginEvent login = 2;
  if (_internal_has_login()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::login(this), target, stream);
  }

  // .grpc.UpdateEvent update = 3;
  if (_internal_has_update()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::update(this), target, stream);
  }

  // .grpc.CacheEvent cache = 4;
  if (_internal_has_cache()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::cache(this), target, stream);
  }

  // .grpc.MailSettingsEvent mailSettings = 5;
  if (_internal_has_mailsettings()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::mailsettings(this), target, stream);
  }

  // .grpc.KeychainEvent keychain = 6;
  if (_internal_has_keychain()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::keychain(this), target, stream);
  }

  // .grpc.MailEvent mail = 7;
  if (_internal_has_mail()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::mail(this), target, stream);
  }

  // .grpc.UserEvent user = 8;
  if (_internal_has_user()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::user(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.StreamEvent)
  return target;
}

size_t StreamEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.StreamEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.AppEvent app = 1;
    case kApp: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.app_);
      break;
    }
    // .grpc.LoginEvent login = 2;
    case kLogin: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.login_);
      break;
    }
    // .grpc.UpdateEvent update = 3;
    case kUpdate: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.update_);
      break;
    }
    // .grpc.CacheEvent cache = 4;
    case kCache: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.cache_);
      break;
    }
    // .grpc.MailSettingsEvent mailSettings = 5;
    case kMailSettings: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.mailsettings_);
      break;
    }
    // .grpc.KeychainEvent keychain = 6;
    case kKeychain: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.keychain_);
      break;
    }
    // .grpc.MailEvent mail = 7;
    case kMail: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.mail_);
      break;
    }
    // .grpc.UserEvent user = 8;
    case kUser: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.user_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData StreamEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    StreamEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*StreamEvent::GetClassData() const { return &_class_data_; }

void StreamEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<StreamEvent *>(to)->MergeFrom(
      static_cast<const StreamEvent &>(from));
}


void StreamEvent::MergeFrom(const StreamEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.StreamEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kApp: {
      _internal_mutable_app()->::grpc::AppEvent::MergeFrom(from._internal_app());
      break;
    }
    case kLogin: {
      _internal_mutable_login()->::grpc::LoginEvent::MergeFrom(from._internal_login());
      break;
    }
    case kUpdate: {
      _internal_mutable_update()->::grpc::UpdateEvent::MergeFrom(from._internal_update());
      break;
    }
    case kCache: {
      _internal_mutable_cache()->::grpc::CacheEvent::MergeFrom(from._internal_cache());
      break;
    }
    case kMailSettings: {
      _internal_mutable_mailsettings()->::grpc::MailSettingsEvent::MergeFrom(from._internal_mailsettings());
      break;
    }
    case kKeychain: {
      _internal_mutable_keychain()->::grpc::KeychainEvent::MergeFrom(from._internal_keychain());
      break;
    }
    case kMail: {
      _internal_mutable_mail()->::grpc::MailEvent::MergeFrom(from._internal_mail());
      break;
    }
    case kUser: {
      _internal_mutable_user()->::grpc::UserEvent::MergeFrom(from._internal_user());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void StreamEvent::CopyFrom(const StreamEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.StreamEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StreamEvent::IsInitialized() const {
  return true;
}

void StreamEvent::InternalSwap(StreamEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata StreamEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[11]);
}

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

class AppEvent::_Internal {
 public:
  static const ::grpc::InternetStatusEvent& internetstatus(const AppEvent* msg);
  static const ::grpc::AutostartFinishedEvent& autostartfinished(const AppEvent* msg);
  static const ::grpc::ResetFinishedEvent& resetfinished(const AppEvent* msg);
  static const ::grpc::ReportBugFinishedEvent& reportbugfinished(const AppEvent* msg);
  static const ::grpc::ReportBugSuccessEvent& reportbugsuccess(const AppEvent* msg);
  static const ::grpc::ReportBugErrorEvent& reportbugerror(const AppEvent* msg);
  static const ::grpc::ShowMainWindowEvent& showmainwindow(const AppEvent* msg);
};

const ::grpc::InternetStatusEvent&
AppEvent::_Internal::internetstatus(const AppEvent* msg) {
  return *msg->event_.internetstatus_;
}
const ::grpc::AutostartFinishedEvent&
AppEvent::_Internal::autostartfinished(const AppEvent* msg) {
  return *msg->event_.autostartfinished_;
}
const ::grpc::ResetFinishedEvent&
AppEvent::_Internal::resetfinished(const AppEvent* msg) {
  return *msg->event_.resetfinished_;
}
const ::grpc::ReportBugFinishedEvent&
AppEvent::_Internal::reportbugfinished(const AppEvent* msg) {
  return *msg->event_.reportbugfinished_;
}
const ::grpc::ReportBugSuccessEvent&
AppEvent::_Internal::reportbugsuccess(const AppEvent* msg) {
  return *msg->event_.reportbugsuccess_;
}
const ::grpc::ReportBugErrorEvent&
AppEvent::_Internal::reportbugerror(const AppEvent* msg) {
  return *msg->event_.reportbugerror_;
}
const ::grpc::ShowMainWindowEvent&
AppEvent::_Internal::showmainwindow(const AppEvent* msg) {
  return *msg->event_.showmainwindow_;
}
void AppEvent::set_allocated_internetstatus(::grpc::InternetStatusEvent* internetstatus) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (internetstatus) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::InternetStatusEvent>::GetOwningArena(internetstatus);
    if (message_arena != submessage_arena) {
      internetstatus = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, internetstatus, submessage_arena);
    }
    set_has_internetstatus();
    event_.internetstatus_ = internetstatus;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.internetStatus)
}
void AppEvent::set_allocated_autostartfinished(::grpc::AutostartFinishedEvent* autostartfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (autostartfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::AutostartFinishedEvent>::GetOwningArena(autostartfinished);
    if (message_arena != submessage_arena) {
      autostartfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, autostartfinished, submessage_arena);
    }
    set_has_autostartfinished();
    event_.autostartfinished_ = autostartfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.autostartFinished)
}
void AppEvent::set_allocated_resetfinished(::grpc::ResetFinishedEvent* resetfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (resetfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ResetFinishedEvent>::GetOwningArena(resetfinished);
    if (message_arena != submessage_arena) {
      resetfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, resetfinished, submessage_arena);
    }
    set_has_resetfinished();
    event_.resetfinished_ = resetfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.resetFinished)
}
void AppEvent::set_allocated_reportbugfinished(::grpc::ReportBugFinishedEvent* reportbugfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (reportbugfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ReportBugFinishedEvent>::GetOwningArena(reportbugfinished);
    if (message_arena != submessage_arena) {
      reportbugfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reportbugfinished, submessage_arena);
    }
    set_has_reportbugfinished();
    event_.reportbugfinished_ = reportbugfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.reportBugFinished)
}
void AppEvent::set_allocated_reportbugsuccess(::grpc::ReportBugSuccessEvent* reportbugsuccess) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (reportbugsuccess) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ReportBugSuccessEvent>::GetOwningArena(reportbugsuccess);
    if (message_arena != submessage_arena) {
      reportbugsuccess = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reportbugsuccess, submessage_arena);
    }
    set_has_reportbugsuccess();
    event_.reportbugsuccess_ = reportbugsuccess;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.reportBugSuccess)
}
void AppEvent::set_allocated_reportbugerror(::grpc::ReportBugErrorEvent* reportbugerror) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (reportbugerror) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ReportBugErrorEvent>::GetOwningArena(reportbugerror);
    if (message_arena != submessage_arena) {
      reportbugerror = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, reportbugerror, submessage_arena);
    }
    set_has_reportbugerror();
    event_.reportbugerror_ = reportbugerror;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.reportBugError)
}
void AppEvent::set_allocated_showmainwindow(::grpc::ShowMainWindowEvent* showmainwindow) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (showmainwindow) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ShowMainWindowEvent>::GetOwningArena(showmainwindow);
    if (message_arena != submessage_arena) {
      showmainwindow = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, showmainwindow, submessage_arena);
    }
    set_has_showmainwindow();
    event_.showmainwindow_ = showmainwindow;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.AppEvent.showMainWindow)
}
AppEvent::AppEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.AppEvent)
}
AppEvent::AppEvent(const AppEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kInternetStatus: {
      _internal_mutable_internetstatus()->::grpc::InternetStatusEvent::MergeFrom(from._internal_internetstatus());
      break;
    }
    case kAutostartFinished: {
      _internal_mutable_autostartfinished()->::grpc::AutostartFinishedEvent::MergeFrom(from._internal_autostartfinished());
      break;
    }
    case kResetFinished: {
      _internal_mutable_resetfinished()->::grpc::ResetFinishedEvent::MergeFrom(from._internal_resetfinished());
      break;
    }
    case kReportBugFinished: {
      _internal_mutable_reportbugfinished()->::grpc::ReportBugFinishedEvent::MergeFrom(from._internal_reportbugfinished());
      break;
    }
    case kReportBugSuccess: {
      _internal_mutable_reportbugsuccess()->::grpc::ReportBugSuccessEvent::MergeFrom(from._internal_reportbugsuccess());
      break;
    }
    case kReportBugError: {
      _internal_mutable_reportbugerror()->::grpc::ReportBugErrorEvent::MergeFrom(from._internal_reportbugerror());
      break;
    }
    case kShowMainWindow: {
      _internal_mutable_showmainwindow()->::grpc::ShowMainWindowEvent::MergeFrom(from._internal_showmainwindow());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.AppEvent)
}

inline void AppEvent::SharedCtor() {
clear_has_event();
}

AppEvent::~AppEvent() {
  // @@protoc_insertion_point(destructor:grpc.AppEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AppEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void AppEvent::ArenaDtor(void* object) {
  AppEvent* _this = reinterpret_cast< AppEvent* >(object);
  (void)_this;
}
void AppEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AppEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AppEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.AppEvent)
  switch (event_case()) {
    case kInternetStatus: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.internetstatus_;
      }
      break;
    }
    case kAutostartFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.autostartfinished_;
      }
      break;
    }
    case kResetFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.resetfinished_;
      }
      break;
    }
    case kReportBugFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.reportbugfinished_;
      }
      break;
    }
    case kReportBugSuccess: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.reportbugsuccess_;
      }
      break;
    }
    case kReportBugError: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.reportbugerror_;
      }
      break;
    }
    case kShowMainWindow: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.showmainwindow_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void AppEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.AppEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AppEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.InternetStatusEvent internetStatus = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_internetstatus(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.AutostartFinishedEvent autostartFinished = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_autostartfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ResetFinishedEvent resetFinished = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_resetfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ReportBugFinishedEvent reportBugFinished = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_reportbugfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ReportBugSuccessEvent reportBugSuccess = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_reportbugsuccess(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ReportBugErrorEvent reportBugError = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_reportbugerror(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ShowMainWindowEvent showMainWindow = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_showmainwindow(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* AppEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.AppEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.InternetStatusEvent internetStatus = 1;
  if (_internal_has_internetstatus()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::internetstatus(this), target, stream);
  }

  // .grpc.AutostartFinishedEvent autostartFinished = 2;
  if (_internal_has_autostartfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::autostartfinished(this), target, stream);
  }

  // .grpc.ResetFinishedEvent resetFinished = 3;
  if (_internal_has_resetfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::resetfinished(this), target, stream);
  }

  // .grpc.ReportBugFinishedEvent reportBugFinished = 4;
  if (_internal_has_reportbugfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::reportbugfinished(this), target, stream);
  }

  // .grpc.ReportBugSuccessEvent reportBugSuccess = 5;
  if (_internal_has_reportbugsuccess()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::reportbugsuccess(this), target, stream);
  }

  // .grpc.ReportBugErrorEvent reportBugError = 6;
  if (_internal_has_reportbugerror()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::reportbugerror(this), target, stream);
  }

  // .grpc.ShowMainWindowEvent showMainWindow = 7;
  if (_internal_has_showmainwindow()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::showmainwindow(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.AppEvent)
  return target;
}

size_t AppEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.AppEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.InternetStatusEvent internetStatus = 1;
    case kInternetStatus: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.internetstatus_);
      break;
    }
    // .grpc.AutostartFinishedEvent autostartFinished = 2;
    case kAutostartFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.autostartfinished_);
      break;
    }
    // .grpc.ResetFinishedEvent resetFinished = 3;
    case kResetFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.resetfinished_);
      break;
    }
    // .grpc.ReportBugFinishedEvent reportBugFinished = 4;
    case kReportBugFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.reportbugfinished_);
      break;
    }
    // .grpc.ReportBugSuccessEvent reportBugSuccess = 5;
    case kReportBugSuccess: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.reportbugsuccess_);
      break;
    }
    // .grpc.ReportBugErrorEvent reportBugError = 6;
    case kReportBugError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.reportbugerror_);
      break;
    }
    // .grpc.ShowMainWindowEvent showMainWindow = 7;
    case kShowMainWindow: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.showmainwindow_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AppEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AppEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AppEvent::GetClassData() const { return &_class_data_; }

void AppEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AppEvent *>(to)->MergeFrom(
      static_cast<const AppEvent &>(from));
}


void AppEvent::MergeFrom(const AppEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.AppEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kInternetStatus: {
      _internal_mutable_internetstatus()->::grpc::InternetStatusEvent::MergeFrom(from._internal_internetstatus());
      break;
    }
    case kAutostartFinished: {
      _internal_mutable_autostartfinished()->::grpc::AutostartFinishedEvent::MergeFrom(from._internal_autostartfinished());
      break;
    }
    case kResetFinished: {
      _internal_mutable_resetfinished()->::grpc::ResetFinishedEvent::MergeFrom(from._internal_resetfinished());
      break;
    }
    case kReportBugFinished: {
      _internal_mutable_reportbugfinished()->::grpc::ReportBugFinishedEvent::MergeFrom(from._internal_reportbugfinished());
      break;
    }
    case kReportBugSuccess: {
      _internal_mutable_reportbugsuccess()->::grpc::ReportBugSuccessEvent::MergeFrom(from._internal_reportbugsuccess());
      break;
    }
    case kReportBugError: {
      _internal_mutable_reportbugerror()->::grpc::ReportBugErrorEvent::MergeFrom(from._internal_reportbugerror());
      break;
    }
    case kShowMainWindow: {
      _internal_mutable_showmainwindow()->::grpc::ShowMainWindowEvent::MergeFrom(from._internal_showmainwindow());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AppEvent::CopyFrom(const AppEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.AppEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AppEvent::IsInitialized() const {
  return true;
}

void AppEvent::InternalSwap(AppEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata AppEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[12]);
}

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

class InternetStatusEvent::_Internal {
 public:
};

InternetStatusEvent::InternetStatusEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.InternetStatusEvent)
}
InternetStatusEvent::InternetStatusEvent(const InternetStatusEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  connected_ = from.connected_;
  // @@protoc_insertion_point(copy_constructor:grpc.InternetStatusEvent)
}

inline void InternetStatusEvent::SharedCtor() {
connected_ = false;
}

InternetStatusEvent::~InternetStatusEvent() {
  // @@protoc_insertion_point(destructor:grpc.InternetStatusEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void InternetStatusEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void InternetStatusEvent::ArenaDtor(void* object) {
  InternetStatusEvent* _this = reinterpret_cast< InternetStatusEvent* >(object);
  (void)_this;
}
void InternetStatusEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void InternetStatusEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void InternetStatusEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.InternetStatusEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  connected_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* InternetStatusEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool connected = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          connected_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* InternetStatusEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.InternetStatusEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool connected = 1;
  if (this->_internal_connected() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_connected(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.InternetStatusEvent)
  return target;
}

size_t InternetStatusEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.InternetStatusEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bool connected = 1;
  if (this->_internal_connected() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData InternetStatusEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    InternetStatusEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*InternetStatusEvent::GetClassData() const { return &_class_data_; }

void InternetStatusEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<InternetStatusEvent *>(to)->MergeFrom(
      static_cast<const InternetStatusEvent &>(from));
}


void InternetStatusEvent::MergeFrom(const InternetStatusEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.InternetStatusEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_connected() != 0) {
    _internal_set_connected(from._internal_connected());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void InternetStatusEvent::CopyFrom(const InternetStatusEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.InternetStatusEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool InternetStatusEvent::IsInitialized() const {
  return true;
}

void InternetStatusEvent::InternalSwap(InternetStatusEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(connected_, other->connected_);
}

::PROTOBUF_NAMESPACE_ID::Metadata InternetStatusEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[13]);
}

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

class AutostartFinishedEvent::_Internal {
 public:
};

AutostartFinishedEvent::AutostartFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.AutostartFinishedEvent)
}
AutostartFinishedEvent::AutostartFinishedEvent(const AutostartFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.AutostartFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AutostartFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AutostartFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata AutostartFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[14]);
}

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

class ResetFinishedEvent::_Internal {
 public:
};

ResetFinishedEvent::ResetFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ResetFinishedEvent)
}
ResetFinishedEvent::ResetFinishedEvent(const ResetFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ResetFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ResetFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ResetFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ResetFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[15]);
}

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

class ReportBugFinishedEvent::_Internal {
 public:
};

ReportBugFinishedEvent::ReportBugFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ReportBugFinishedEvent)
}
ReportBugFinishedEvent::ReportBugFinishedEvent(const ReportBugFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ReportBugFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReportBugFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReportBugFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ReportBugFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[16]);
}

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

class ReportBugSuccessEvent::_Internal {
 public:
};

ReportBugSuccessEvent::ReportBugSuccessEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ReportBugSuccessEvent)
}
ReportBugSuccessEvent::ReportBugSuccessEvent(const ReportBugSuccessEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ReportBugSuccessEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReportBugSuccessEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReportBugSuccessEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ReportBugSuccessEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[17]);
}

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

class ReportBugErrorEvent::_Internal {
 public:
};

ReportBugErrorEvent::ReportBugErrorEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ReportBugErrorEvent)
}
ReportBugErrorEvent::ReportBugErrorEvent(const ReportBugErrorEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ReportBugErrorEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReportBugErrorEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReportBugErrorEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ReportBugErrorEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[18]);
}

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

class ShowMainWindowEvent::_Internal {
 public:
};

ShowMainWindowEvent::ShowMainWindowEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ShowMainWindowEvent)
}
ShowMainWindowEvent::ShowMainWindowEvent(const ShowMainWindowEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ShowMainWindowEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ShowMainWindowEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ShowMainWindowEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ShowMainWindowEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[19]);
}

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

class LoginEvent::_Internal {
 public:
  static const ::grpc::LoginErrorEvent& error(const LoginEvent* msg);
  static const ::grpc::LoginTfaRequestedEvent& tfarequested(const LoginEvent* msg);
  static const ::grpc::LoginTwoPasswordsRequestedEvent& twopasswordrequested(const LoginEvent* msg);
  static const ::grpc::LoginFinishedEvent& finished(const LoginEvent* msg);
};

const ::grpc::LoginErrorEvent&
LoginEvent::_Internal::error(const LoginEvent* msg) {
  return *msg->event_.error_;
}
const ::grpc::LoginTfaRequestedEvent&
LoginEvent::_Internal::tfarequested(const LoginEvent* msg) {
  return *msg->event_.tfarequested_;
}
const ::grpc::LoginTwoPasswordsRequestedEvent&
LoginEvent::_Internal::twopasswordrequested(const LoginEvent* msg) {
  return *msg->event_.twopasswordrequested_;
}
const ::grpc::LoginFinishedEvent&
LoginEvent::_Internal::finished(const LoginEvent* msg) {
  return *msg->event_.finished_;
}
void LoginEvent::set_allocated_error(::grpc::LoginErrorEvent* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::LoginErrorEvent>::GetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    event_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.LoginEvent.error)
}
void LoginEvent::set_allocated_tfarequested(::grpc::LoginTfaRequestedEvent* tfarequested) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (tfarequested) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::LoginTfaRequestedEvent>::GetOwningArena(tfarequested);
    if (message_arena != submessage_arena) {
      tfarequested = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tfarequested, submessage_arena);
    }
    set_has_tfarequested();
    event_.tfarequested_ = tfarequested;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.LoginEvent.tfaRequested)
}
void LoginEvent::set_allocated_twopasswordrequested(::grpc::LoginTwoPasswordsRequestedEvent* twopasswordrequested) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (twopasswordrequested) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::LoginTwoPasswordsRequestedEvent>::GetOwningArena(twopasswordrequested);
    if (message_arena != submessage_arena) {
      twopasswordrequested = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, twopasswordrequested, submessage_arena);
    }
    set_has_twopasswordrequested();
    event_.twopasswordrequested_ = twopasswordrequested;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.LoginEvent.twoPasswordRequested)
}
void LoginEvent::set_allocated_finished(::grpc::LoginFinishedEvent* finished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (finished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::LoginFinishedEvent>::GetOwningArena(finished);
    if (message_arena != submessage_arena) {
      finished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, finished, submessage_arena);
    }
    set_has_finished();
    event_.finished_ = finished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.LoginEvent.finished)
}
LoginEvent::LoginEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginEvent)
}
LoginEvent::LoginEvent(const LoginEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::LoginErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kTfaRequested: {
      _internal_mutable_tfarequested()->::grpc::LoginTfaRequestedEvent::MergeFrom(from._internal_tfarequested());
      break;
    }
    case kTwoPasswordRequested: {
      _internal_mutable_twopasswordrequested()->::grpc::LoginTwoPasswordsRequestedEvent::MergeFrom(from._internal_twopasswordrequested());
      break;
    }
    case kFinished: {
      _internal_mutable_finished()->::grpc::LoginFinishedEvent::MergeFrom(from._internal_finished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.LoginEvent)
}

inline void LoginEvent::SharedCtor() {
clear_has_event();
}

LoginEvent::~LoginEvent() {
  // @@protoc_insertion_point(destructor:grpc.LoginEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void LoginEvent::ArenaDtor(void* object) {
  LoginEvent* _this = reinterpret_cast< LoginEvent* >(object);
  (void)_this;
}
void LoginEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.LoginEvent)
  switch (event_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.error_;
      }
      break;
    }
    case kTfaRequested: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.tfarequested_;
      }
      break;
    }
    case kTwoPasswordRequested: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.twopasswordrequested_;
      }
      break;
    }
    case kFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.finished_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void LoginEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.LoginErrorEvent error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.LoginTfaRequestedEvent tfaRequested = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_tfarequested(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.LoginTwoPasswordsRequestedEvent twoPasswordRequested = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_twopasswordrequested(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.LoginFinishedEvent finished = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_finished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.LoginErrorEvent error = 1;
  if (_internal_has_error()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::error(this), target, stream);
  }

  // .grpc.LoginTfaRequestedEvent tfaRequested = 2;
  if (_internal_has_tfarequested()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::tfarequested(this), target, stream);
  }

  // .grpc.LoginTwoPasswordsRequestedEvent twoPasswordRequested = 3;
  if (_internal_has_twopasswordrequested()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::twopasswordrequested(this), target, stream);
  }

  // .grpc.LoginFinishedEvent finished = 4;
  if (_internal_has_finished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::finished(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginEvent)
  return target;
}

size_t LoginEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.LoginErrorEvent error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.error_);
      break;
    }
    // .grpc.LoginTfaRequestedEvent tfaRequested = 2;
    case kTfaRequested: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.tfarequested_);
      break;
    }
    // .grpc.LoginTwoPasswordsRequestedEvent twoPasswordRequested = 3;
    case kTwoPasswordRequested: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.twopasswordrequested_);
      break;
    }
    // .grpc.LoginFinishedEvent finished = 4;
    case kFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.finished_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginEvent::GetClassData() const { return &_class_data_; }

void LoginEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginEvent *>(to)->MergeFrom(
      static_cast<const LoginEvent &>(from));
}


void LoginEvent::MergeFrom(const LoginEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::LoginErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kTfaRequested: {
      _internal_mutable_tfarequested()->::grpc::LoginTfaRequestedEvent::MergeFrom(from._internal_tfarequested());
      break;
    }
    case kTwoPasswordRequested: {
      _internal_mutable_twopasswordrequested()->::grpc::LoginTwoPasswordsRequestedEvent::MergeFrom(from._internal_twopasswordrequested());
      break;
    }
    case kFinished: {
      _internal_mutable_finished()->::grpc::LoginFinishedEvent::MergeFrom(from._internal_finished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginEvent::CopyFrom(const LoginEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginEvent::IsInitialized() const {
  return true;
}

void LoginEvent::InternalSwap(LoginEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[20]);
}

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

class LoginErrorEvent::_Internal {
 public:
};

LoginErrorEvent::LoginErrorEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginErrorEvent)
}
LoginErrorEvent::LoginErrorEvent(const LoginErrorEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_message().empty()) {
    message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(), 
      GetArenaForAllocation());
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:grpc.LoginErrorEvent)
}

inline void LoginErrorEvent::SharedCtor() {
message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
type_ = 0;
}

LoginErrorEvent::~LoginErrorEvent() {
  // @@protoc_insertion_point(destructor:grpc.LoginErrorEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginErrorEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void LoginErrorEvent::ArenaDtor(void* object) {
  LoginErrorEvent* _this = reinterpret_cast< LoginErrorEvent* >(object);
  (void)_this;
}
void LoginErrorEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginErrorEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginErrorEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginErrorEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  message_.ClearToEmpty();
  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginErrorEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.LoginErrorType type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::grpc::LoginErrorType>(val));
        } else
          goto handle_unusual;
        continue;
      // string message = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_message();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.LoginErrorEvent.message"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginErrorEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginErrorEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.LoginErrorType type = 1;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  // string message = 2;
  if (!this->_internal_message().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.LoginErrorEvent.message");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_message(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginErrorEvent)
  return target;
}

size_t LoginErrorEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginErrorEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string message = 2;
  if (!this->_internal_message().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_message());
  }

  // .grpc.LoginErrorType type = 1;
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginErrorEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginErrorEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginErrorEvent::GetClassData() const { return &_class_data_; }

void LoginErrorEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginErrorEvent *>(to)->MergeFrom(
      static_cast<const LoginErrorEvent &>(from));
}


void LoginErrorEvent::MergeFrom(const LoginErrorEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginErrorEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_message().empty()) {
    _internal_set_message(from._internal_message());
  }
  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginErrorEvent::CopyFrom(const LoginErrorEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginErrorEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginErrorEvent::IsInitialized() const {
  return true;
}

void LoginErrorEvent::InternalSwap(LoginErrorEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &message_, lhs_arena,
      &other->message_, rhs_arena
  );
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginErrorEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[21]);
}

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

class LoginTfaRequestedEvent::_Internal {
 public:
};

LoginTfaRequestedEvent::LoginTfaRequestedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginTfaRequestedEvent)
}
LoginTfaRequestedEvent::LoginTfaRequestedEvent(const LoginTfaRequestedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.LoginTfaRequestedEvent)
}

inline void LoginTfaRequestedEvent::SharedCtor() {
username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

LoginTfaRequestedEvent::~LoginTfaRequestedEvent() {
  // @@protoc_insertion_point(destructor:grpc.LoginTfaRequestedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginTfaRequestedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void LoginTfaRequestedEvent::ArenaDtor(void* object) {
  LoginTfaRequestedEvent* _this = reinterpret_cast< LoginTfaRequestedEvent* >(object);
  (void)_this;
}
void LoginTfaRequestedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginTfaRequestedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginTfaRequestedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginTfaRequestedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  username_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginTfaRequestedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.LoginTfaRequestedEvent.username"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginTfaRequestedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginTfaRequestedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.LoginTfaRequestedEvent.username");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_username(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginTfaRequestedEvent)
  return target;
}

size_t LoginTfaRequestedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginTfaRequestedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_username());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginTfaRequestedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginTfaRequestedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginTfaRequestedEvent::GetClassData() const { return &_class_data_; }

void LoginTfaRequestedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginTfaRequestedEvent *>(to)->MergeFrom(
      static_cast<const LoginTfaRequestedEvent &>(from));
}


void LoginTfaRequestedEvent::MergeFrom(const LoginTfaRequestedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginTfaRequestedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_username().empty()) {
    _internal_set_username(from._internal_username());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginTfaRequestedEvent::CopyFrom(const LoginTfaRequestedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginTfaRequestedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginTfaRequestedEvent::IsInitialized() const {
  return true;
}

void LoginTfaRequestedEvent::InternalSwap(LoginTfaRequestedEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &username_, lhs_arena,
      &other->username_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginTfaRequestedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[22]);
}

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

class LoginTwoPasswordsRequestedEvent::_Internal {
 public:
};

LoginTwoPasswordsRequestedEvent::LoginTwoPasswordsRequestedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.LoginTwoPasswordsRequestedEvent)
}
LoginTwoPasswordsRequestedEvent::LoginTwoPasswordsRequestedEvent(const LoginTwoPasswordsRequestedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.LoginTwoPasswordsRequestedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginTwoPasswordsRequestedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginTwoPasswordsRequestedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata LoginTwoPasswordsRequestedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[23]);
}

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

class LoginFinishedEvent::_Internal {
 public:
};

LoginFinishedEvent::LoginFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.LoginFinishedEvent)
}
LoginFinishedEvent::LoginFinishedEvent(const LoginFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  wasalreadyloggedin_ = from.wasalreadyloggedin_;
  // @@protoc_insertion_point(copy_constructor:grpc.LoginFinishedEvent)
}

inline void LoginFinishedEvent::SharedCtor() {
wasalreadyloggedin_ = false;
}

LoginFinishedEvent::~LoginFinishedEvent() {
  // @@protoc_insertion_point(destructor:grpc.LoginFinishedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void LoginFinishedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void LoginFinishedEvent::ArenaDtor(void* object) {
  LoginFinishedEvent* _this = reinterpret_cast< LoginFinishedEvent* >(object);
  (void)_this;
}
void LoginFinishedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LoginFinishedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void LoginFinishedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.LoginFinishedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  wasalreadyloggedin_ = false;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LoginFinishedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // bool wasAlreadyLoggedIn = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          wasalreadyloggedin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* LoginFinishedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.LoginFinishedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // bool wasAlreadyLoggedIn = 1;
  if (this->_internal_wasalreadyloggedin() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_wasalreadyloggedin(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.LoginFinishedEvent)
  return target;
}

size_t LoginFinishedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.LoginFinishedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // bool wasAlreadyLoggedIn = 1;
  if (this->_internal_wasalreadyloggedin() != 0) {
    total_size += 1 + 1;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData LoginFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    LoginFinishedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*LoginFinishedEvent::GetClassData() const { return &_class_data_; }

void LoginFinishedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<LoginFinishedEvent *>(to)->MergeFrom(
      static_cast<const LoginFinishedEvent &>(from));
}


void LoginFinishedEvent::MergeFrom(const LoginFinishedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.LoginFinishedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_wasalreadyloggedin() != 0) {
    _internal_set_wasalreadyloggedin(from._internal_wasalreadyloggedin());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void LoginFinishedEvent::CopyFrom(const LoginFinishedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.LoginFinishedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginFinishedEvent::IsInitialized() const {
  return true;
}

void LoginFinishedEvent::InternalSwap(LoginFinishedEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(wasalreadyloggedin_, other->wasalreadyloggedin_);
}

::PROTOBUF_NAMESPACE_ID::Metadata LoginFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[24]);
}

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

class UpdateEvent::_Internal {
 public:
  static const ::grpc::UpdateErrorEvent& error(const UpdateEvent* msg);
  static const ::grpc::UpdateManualReadyEvent& manualready(const UpdateEvent* msg);
  static const ::grpc::UpdateManualRestartNeededEvent& manualrestartneeded(const UpdateEvent* msg);
  static const ::grpc::UpdateForceEvent& force(const UpdateEvent* msg);
  static const ::grpc::UpdateSilentRestartNeeded& silentrestartneeded(const UpdateEvent* msg);
  static const ::grpc::UpdateIsLatestVersion& islatestversion(const UpdateEvent* msg);
  static const ::grpc::UpdateCheckFinished& checkfinished(const UpdateEvent* msg);
};

const ::grpc::UpdateErrorEvent&
UpdateEvent::_Internal::error(const UpdateEvent* msg) {
  return *msg->event_.error_;
}
const ::grpc::UpdateManualReadyEvent&
UpdateEvent::_Internal::manualready(const UpdateEvent* msg) {
  return *msg->event_.manualready_;
}
const ::grpc::UpdateManualRestartNeededEvent&
UpdateEvent::_Internal::manualrestartneeded(const UpdateEvent* msg) {
  return *msg->event_.manualrestartneeded_;
}
const ::grpc::UpdateForceEvent&
UpdateEvent::_Internal::force(const UpdateEvent* msg) {
  return *msg->event_.force_;
}
const ::grpc::UpdateSilentRestartNeeded&
UpdateEvent::_Internal::silentrestartneeded(const UpdateEvent* msg) {
  return *msg->event_.silentrestartneeded_;
}
const ::grpc::UpdateIsLatestVersion&
UpdateEvent::_Internal::islatestversion(const UpdateEvent* msg) {
  return *msg->event_.islatestversion_;
}
const ::grpc::UpdateCheckFinished&
UpdateEvent::_Internal::checkfinished(const UpdateEvent* msg) {
  return *msg->event_.checkfinished_;
}
void UpdateEvent::set_allocated_error(::grpc::UpdateErrorEvent* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateErrorEvent>::GetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    event_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.error)
}
void UpdateEvent::set_allocated_manualready(::grpc::UpdateManualReadyEvent* manualready) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (manualready) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateManualReadyEvent>::GetOwningArena(manualready);
    if (message_arena != submessage_arena) {
      manualready = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, manualready, submessage_arena);
    }
    set_has_manualready();
    event_.manualready_ = manualready;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.manualReady)
}
void UpdateEvent::set_allocated_manualrestartneeded(::grpc::UpdateManualRestartNeededEvent* manualrestartneeded) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (manualrestartneeded) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateManualRestartNeededEvent>::GetOwningArena(manualrestartneeded);
    if (message_arena != submessage_arena) {
      manualrestartneeded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, manualrestartneeded, submessage_arena);
    }
    set_has_manualrestartneeded();
    event_.manualrestartneeded_ = manualrestartneeded;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.manualRestartNeeded)
}
void UpdateEvent::set_allocated_force(::grpc::UpdateForceEvent* force) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (force) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateForceEvent>::GetOwningArena(force);
    if (message_arena != submessage_arena) {
      force = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, force, submessage_arena);
    }
    set_has_force();
    event_.force_ = force;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.force)
}
void UpdateEvent::set_allocated_silentrestartneeded(::grpc::UpdateSilentRestartNeeded* silentrestartneeded) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (silentrestartneeded) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateSilentRestartNeeded>::GetOwningArena(silentrestartneeded);
    if (message_arena != submessage_arena) {
      silentrestartneeded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, silentrestartneeded, submessage_arena);
    }
    set_has_silentrestartneeded();
    event_.silentrestartneeded_ = silentrestartneeded;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.silentRestartNeeded)
}
void UpdateEvent::set_allocated_islatestversion(::grpc::UpdateIsLatestVersion* islatestversion) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (islatestversion) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateIsLatestVersion>::GetOwningArena(islatestversion);
    if (message_arena != submessage_arena) {
      islatestversion = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, islatestversion, submessage_arena);
    }
    set_has_islatestversion();
    event_.islatestversion_ = islatestversion;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.isLatestVersion)
}
void UpdateEvent::set_allocated_checkfinished(::grpc::UpdateCheckFinished* checkfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (checkfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UpdateCheckFinished>::GetOwningArena(checkfinished);
    if (message_arena != submessage_arena) {
      checkfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, checkfinished, submessage_arena);
    }
    set_has_checkfinished();
    event_.checkfinished_ = checkfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UpdateEvent.checkFinished)
}
UpdateEvent::UpdateEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateEvent)
}
UpdateEvent::UpdateEvent(const UpdateEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::UpdateErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kManualReady: {
      _internal_mutable_manualready()->::grpc::UpdateManualReadyEvent::MergeFrom(from._internal_manualready());
      break;
    }
    case kManualRestartNeeded: {
      _internal_mutable_manualrestartneeded()->::grpc::UpdateManualRestartNeededEvent::MergeFrom(from._internal_manualrestartneeded());
      break;
    }
    case kForce: {
      _internal_mutable_force()->::grpc::UpdateForceEvent::MergeFrom(from._internal_force());
      break;
    }
    case kSilentRestartNeeded: {
      _internal_mutable_silentrestartneeded()->::grpc::UpdateSilentRestartNeeded::MergeFrom(from._internal_silentrestartneeded());
      break;
    }
    case kIsLatestVersion: {
      _internal_mutable_islatestversion()->::grpc::UpdateIsLatestVersion::MergeFrom(from._internal_islatestversion());
      break;
    }
    case kCheckFinished: {
      _internal_mutable_checkfinished()->::grpc::UpdateCheckFinished::MergeFrom(from._internal_checkfinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateEvent)
}

inline void UpdateEvent::SharedCtor() {
clear_has_event();
}

UpdateEvent::~UpdateEvent() {
  // @@protoc_insertion_point(destructor:grpc.UpdateEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UpdateEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void UpdateEvent::ArenaDtor(void* object) {
  UpdateEvent* _this = reinterpret_cast< UpdateEvent* >(object);
  (void)_this;
}
void UpdateEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UpdateEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UpdateEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.UpdateEvent)
  switch (event_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.error_;
      }
      break;
    }
    case kManualReady: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.manualready_;
      }
      break;
    }
    case kManualRestartNeeded: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.manualrestartneeded_;
      }
      break;
    }
    case kForce: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.force_;
      }
      break;
    }
    case kSilentRestartNeeded: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.silentrestartneeded_;
      }
      break;
    }
    case kIsLatestVersion: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.islatestversion_;
      }
      break;
    }
    case kCheckFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.checkfinished_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void UpdateEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UpdateEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UpdateEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.UpdateErrorEvent error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateManualReadyEvent manualReady = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_manualready(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateManualRestartNeededEvent manualRestartNeeded = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_manualrestartneeded(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateForceEvent force = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_force(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateSilentRestartNeeded silentRestartNeeded = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_silentrestartneeded(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateIsLatestVersion isLatestVersion = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_islatestversion(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UpdateCheckFinished checkFinished = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_checkfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UpdateEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UpdateEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.UpdateErrorEvent error = 1;
  if (_internal_has_error()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::error(this), target, stream);
  }

  // .grpc.UpdateManualReadyEvent manualReady = 2;
  if (_internal_has_manualready()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::manualready(this), target, stream);
  }

  // .grpc.UpdateManualRestartNeededEvent manualRestartNeeded = 3;
  if (_internal_has_manualrestartneeded()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::manualrestartneeded(this), target, stream);
  }

  // .grpc.UpdateForceEvent force = 4;
  if (_internal_has_force()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::force(this), target, stream);
  }

  // .grpc.UpdateSilentRestartNeeded silentRestartNeeded = 5;
  if (_internal_has_silentrestartneeded()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::silentrestartneeded(this), target, stream);
  }

  // .grpc.UpdateIsLatestVersion isLatestVersion = 6;
  if (_internal_has_islatestversion()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::islatestversion(this), target, stream);
  }

  // .grpc.UpdateCheckFinished checkFinished = 7;
  if (_internal_has_checkfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::checkfinished(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UpdateEvent)
  return target;
}

size_t UpdateEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UpdateEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.UpdateErrorEvent error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.error_);
      break;
    }
    // .grpc.UpdateManualReadyEvent manualReady = 2;
    case kManualReady: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.manualready_);
      break;
    }
    // .grpc.UpdateManualRestartNeededEvent manualRestartNeeded = 3;
    case kManualRestartNeeded: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.manualrestartneeded_);
      break;
    }
    // .grpc.UpdateForceEvent force = 4;
    case kForce: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.force_);
      break;
    }
    // .grpc.UpdateSilentRestartNeeded silentRestartNeeded = 5;
    case kSilentRestartNeeded: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.silentrestartneeded_);
      break;
    }
    // .grpc.UpdateIsLatestVersion isLatestVersion = 6;
    case kIsLatestVersion: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.islatestversion_);
      break;
    }
    // .grpc.UpdateCheckFinished checkFinished = 7;
    case kCheckFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.checkfinished_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UpdateEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateEvent::GetClassData() const { return &_class_data_; }

void UpdateEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UpdateEvent *>(to)->MergeFrom(
      static_cast<const UpdateEvent &>(from));
}


void UpdateEvent::MergeFrom(const UpdateEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UpdateEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::UpdateErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kManualReady: {
      _internal_mutable_manualready()->::grpc::UpdateManualReadyEvent::MergeFrom(from._internal_manualready());
      break;
    }
    case kManualRestartNeeded: {
      _internal_mutable_manualrestartneeded()->::grpc::UpdateManualRestartNeededEvent::MergeFrom(from._internal_manualrestartneeded());
      break;
    }
    case kForce: {
      _internal_mutable_force()->::grpc::UpdateForceEvent::MergeFrom(from._internal_force());
      break;
    }
    case kSilentRestartNeeded: {
      _internal_mutable_silentrestartneeded()->::grpc::UpdateSilentRestartNeeded::MergeFrom(from._internal_silentrestartneeded());
      break;
    }
    case kIsLatestVersion: {
      _internal_mutable_islatestversion()->::grpc::UpdateIsLatestVersion::MergeFrom(from._internal_islatestversion());
      break;
    }
    case kCheckFinished: {
      _internal_mutable_checkfinished()->::grpc::UpdateCheckFinished::MergeFrom(from._internal_checkfinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UpdateEvent::CopyFrom(const UpdateEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UpdateEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UpdateEvent::IsInitialized() const {
  return true;
}

void UpdateEvent::InternalSwap(UpdateEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata UpdateEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[25]);
}

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

class UpdateErrorEvent::_Internal {
 public:
};

UpdateErrorEvent::UpdateErrorEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateErrorEvent)
}
UpdateErrorEvent::UpdateErrorEvent(const UpdateErrorEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateErrorEvent)
}

inline void UpdateErrorEvent::SharedCtor() {
type_ = 0;
}

UpdateErrorEvent::~UpdateErrorEvent() {
  // @@protoc_insertion_point(destructor:grpc.UpdateErrorEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UpdateErrorEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void UpdateErrorEvent::ArenaDtor(void* object) {
  UpdateErrorEvent* _this = reinterpret_cast< UpdateErrorEvent* >(object);
  (void)_this;
}
void UpdateErrorEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UpdateErrorEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UpdateErrorEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UpdateErrorEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UpdateErrorEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.UpdateErrorType type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::grpc::UpdateErrorType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UpdateErrorEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UpdateErrorEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.UpdateErrorType type = 1;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UpdateErrorEvent)
  return target;
}

size_t UpdateErrorEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UpdateErrorEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .grpc.UpdateErrorType type = 1;
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateErrorEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UpdateErrorEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateErrorEvent::GetClassData() const { return &_class_data_; }

void UpdateErrorEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UpdateErrorEvent *>(to)->MergeFrom(
      static_cast<const UpdateErrorEvent &>(from));
}


void UpdateErrorEvent::MergeFrom(const UpdateErrorEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UpdateErrorEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UpdateErrorEvent::CopyFrom(const UpdateErrorEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UpdateErrorEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UpdateErrorEvent::IsInitialized() const {
  return true;
}

void UpdateErrorEvent::InternalSwap(UpdateErrorEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UpdateErrorEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[26]);
}

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

class UpdateManualReadyEvent::_Internal {
 public:
};

UpdateManualReadyEvent::UpdateManualReadyEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateManualReadyEvent)
}
UpdateManualReadyEvent::UpdateManualReadyEvent(const UpdateManualReadyEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_version().empty()) {
    version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_version(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateManualReadyEvent)
}

inline void UpdateManualReadyEvent::SharedCtor() {
version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

UpdateManualReadyEvent::~UpdateManualReadyEvent() {
  // @@protoc_insertion_point(destructor:grpc.UpdateManualReadyEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UpdateManualReadyEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void UpdateManualReadyEvent::ArenaDtor(void* object) {
  UpdateManualReadyEvent* _this = reinterpret_cast< UpdateManualReadyEvent* >(object);
  (void)_this;
}
void UpdateManualReadyEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UpdateManualReadyEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UpdateManualReadyEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UpdateManualReadyEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  version_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UpdateManualReadyEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.UpdateManualReadyEvent.version"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UpdateManualReadyEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UpdateManualReadyEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string version = 1;
  if (!this->_internal_version().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.UpdateManualReadyEvent.version");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UpdateManualReadyEvent)
  return target;
}

size_t UpdateManualReadyEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UpdateManualReadyEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string version = 1;
  if (!this->_internal_version().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_version());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateManualReadyEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UpdateManualReadyEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateManualReadyEvent::GetClassData() const { return &_class_data_; }

void UpdateManualReadyEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UpdateManualReadyEvent *>(to)->MergeFrom(
      static_cast<const UpdateManualReadyEvent &>(from));
}


void UpdateManualReadyEvent::MergeFrom(const UpdateManualReadyEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UpdateManualReadyEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_version().empty()) {
    _internal_set_version(from._internal_version());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UpdateManualReadyEvent::CopyFrom(const UpdateManualReadyEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UpdateManualReadyEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UpdateManualReadyEvent::IsInitialized() const {
  return true;
}

void UpdateManualReadyEvent::InternalSwap(UpdateManualReadyEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &version_, lhs_arena,
      &other->version_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata UpdateManualReadyEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[27]);
}

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

class UpdateManualRestartNeededEvent::_Internal {
 public:
};

UpdateManualRestartNeededEvent::UpdateManualRestartNeededEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateManualRestartNeededEvent)
}
UpdateManualRestartNeededEvent::UpdateManualRestartNeededEvent(const UpdateManualRestartNeededEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateManualRestartNeededEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateManualRestartNeededEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateManualRestartNeededEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata UpdateManualRestartNeededEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[28]);
}

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

class UpdateForceEvent::_Internal {
 public:
};

UpdateForceEvent::UpdateForceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateForceEvent)
}
UpdateForceEvent::UpdateForceEvent(const UpdateForceEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_version().empty()) {
    version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_version(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateForceEvent)
}

inline void UpdateForceEvent::SharedCtor() {
version_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

UpdateForceEvent::~UpdateForceEvent() {
  // @@protoc_insertion_point(destructor:grpc.UpdateForceEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UpdateForceEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  version_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void UpdateForceEvent::ArenaDtor(void* object) {
  UpdateForceEvent* _this = reinterpret_cast< UpdateForceEvent* >(object);
  (void)_this;
}
void UpdateForceEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UpdateForceEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UpdateForceEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UpdateForceEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  version_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UpdateForceEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_version();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.UpdateForceEvent.version"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UpdateForceEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UpdateForceEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string version = 1;
  if (!this->_internal_version().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_version().data(), static_cast<int>(this->_internal_version().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.UpdateForceEvent.version");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UpdateForceEvent)
  return target;
}

size_t UpdateForceEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UpdateForceEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string version = 1;
  if (!this->_internal_version().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_version());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateForceEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UpdateForceEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateForceEvent::GetClassData() const { return &_class_data_; }

void UpdateForceEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UpdateForceEvent *>(to)->MergeFrom(
      static_cast<const UpdateForceEvent &>(from));
}


void UpdateForceEvent::MergeFrom(const UpdateForceEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UpdateForceEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_version().empty()) {
    _internal_set_version(from._internal_version());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UpdateForceEvent::CopyFrom(const UpdateForceEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UpdateForceEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UpdateForceEvent::IsInitialized() const {
  return true;
}

void UpdateForceEvent::InternalSwap(UpdateForceEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &version_, lhs_arena,
      &other->version_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata UpdateForceEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[29]);
}

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

class UpdateSilentRestartNeeded::_Internal {
 public:
};

UpdateSilentRestartNeeded::UpdateSilentRestartNeeded(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateSilentRestartNeeded)
}
UpdateSilentRestartNeeded::UpdateSilentRestartNeeded(const UpdateSilentRestartNeeded& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateSilentRestartNeeded)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateSilentRestartNeeded::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateSilentRestartNeeded::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata UpdateSilentRestartNeeded::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[30]);
}

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

class UpdateIsLatestVersion::_Internal {
 public:
};

UpdateIsLatestVersion::UpdateIsLatestVersion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateIsLatestVersion)
}
UpdateIsLatestVersion::UpdateIsLatestVersion(const UpdateIsLatestVersion& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateIsLatestVersion)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateIsLatestVersion::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateIsLatestVersion::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata UpdateIsLatestVersion::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[31]);
}

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

class UpdateCheckFinished::_Internal {
 public:
};

UpdateCheckFinished::UpdateCheckFinished(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.UpdateCheckFinished)
}
UpdateCheckFinished::UpdateCheckFinished(const UpdateCheckFinished& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UpdateCheckFinished)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UpdateCheckFinished::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UpdateCheckFinished::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata UpdateCheckFinished::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[32]);
}

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

class CacheEvent::_Internal {
 public:
  static const ::grpc::CacheErrorEvent& error(const CacheEvent* msg);
  static const ::grpc::CacheLocationChangeSuccessEvent& locationchangedsuccess(const CacheEvent* msg);
  static const ::grpc::ChangeLocalCacheFinishedEvent& changelocalcachefinished(const CacheEvent* msg);
};

const ::grpc::CacheErrorEvent&
CacheEvent::_Internal::error(const CacheEvent* msg) {
  return *msg->event_.error_;
}
const ::grpc::CacheLocationChangeSuccessEvent&
CacheEvent::_Internal::locationchangedsuccess(const CacheEvent* msg) {
  return *msg->event_.locationchangedsuccess_;
}
const ::grpc::ChangeLocalCacheFinishedEvent&
CacheEvent::_Internal::changelocalcachefinished(const CacheEvent* msg) {
  return *msg->event_.changelocalcachefinished_;
}
void CacheEvent::set_allocated_error(::grpc::CacheErrorEvent* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::CacheErrorEvent>::GetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    event_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.CacheEvent.error)
}
void CacheEvent::set_allocated_locationchangedsuccess(::grpc::CacheLocationChangeSuccessEvent* locationchangedsuccess) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (locationchangedsuccess) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::CacheLocationChangeSuccessEvent>::GetOwningArena(locationchangedsuccess);
    if (message_arena != submessage_arena) {
      locationchangedsuccess = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, locationchangedsuccess, submessage_arena);
    }
    set_has_locationchangedsuccess();
    event_.locationchangedsuccess_ = locationchangedsuccess;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.CacheEvent.locationChangedSuccess)
}
void CacheEvent::set_allocated_changelocalcachefinished(::grpc::ChangeLocalCacheFinishedEvent* changelocalcachefinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (changelocalcachefinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ChangeLocalCacheFinishedEvent>::GetOwningArena(changelocalcachefinished);
    if (message_arena != submessage_arena) {
      changelocalcachefinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, changelocalcachefinished, submessage_arena);
    }
    set_has_changelocalcachefinished();
    event_.changelocalcachefinished_ = changelocalcachefinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.CacheEvent.changeLocalCacheFinished)
}
CacheEvent::CacheEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.CacheEvent)
}
CacheEvent::CacheEvent(const CacheEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::CacheErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kLocationChangedSuccess: {
      _internal_mutable_locationchangedsuccess()->::grpc::CacheLocationChangeSuccessEvent::MergeFrom(from._internal_locationchangedsuccess());
      break;
    }
    case kChangeLocalCacheFinished: {
      _internal_mutable_changelocalcachefinished()->::grpc::ChangeLocalCacheFinishedEvent::MergeFrom(from._internal_changelocalcachefinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.CacheEvent)
}

inline void CacheEvent::SharedCtor() {
clear_has_event();
}

CacheEvent::~CacheEvent() {
  // @@protoc_insertion_point(destructor:grpc.CacheEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void CacheEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void CacheEvent::ArenaDtor(void* object) {
  CacheEvent* _this = reinterpret_cast< CacheEvent* >(object);
  (void)_this;
}
void CacheEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CacheEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void CacheEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.CacheEvent)
  switch (event_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.error_;
      }
      break;
    }
    case kLocationChangedSuccess: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.locationchangedsuccess_;
      }
      break;
    }
    case kChangeLocalCacheFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.changelocalcachefinished_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void CacheEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.CacheEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CacheEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.CacheErrorEvent error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.CacheLocationChangeSuccessEvent locationChangedSuccess = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_locationchangedsuccess(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ChangeLocalCacheFinishedEvent changeLocalCacheFinished = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changelocalcachefinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CacheEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.CacheEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.CacheErrorEvent error = 1;
  if (_internal_has_error()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::error(this), target, stream);
  }

  // .grpc.CacheLocationChangeSuccessEvent locationChangedSuccess = 2;
  if (_internal_has_locationchangedsuccess()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::locationchangedsuccess(this), target, stream);
  }

  // .grpc.ChangeLocalCacheFinishedEvent changeLocalCacheFinished = 3;
  if (_internal_has_changelocalcachefinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::changelocalcachefinished(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.CacheEvent)
  return target;
}

size_t CacheEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.CacheEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.CacheErrorEvent error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.error_);
      break;
    }
    // .grpc.CacheLocationChangeSuccessEvent locationChangedSuccess = 2;
    case kLocationChangedSuccess: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.locationchangedsuccess_);
      break;
    }
    // .grpc.ChangeLocalCacheFinishedEvent changeLocalCacheFinished = 3;
    case kChangeLocalCacheFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.changelocalcachefinished_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CacheEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    CacheEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CacheEvent::GetClassData() const { return &_class_data_; }

void CacheEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<CacheEvent *>(to)->MergeFrom(
      static_cast<const CacheEvent &>(from));
}


void CacheEvent::MergeFrom(const CacheEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.CacheEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::CacheErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kLocationChangedSuccess: {
      _internal_mutable_locationchangedsuccess()->::grpc::CacheLocationChangeSuccessEvent::MergeFrom(from._internal_locationchangedsuccess());
      break;
    }
    case kChangeLocalCacheFinished: {
      _internal_mutable_changelocalcachefinished()->::grpc::ChangeLocalCacheFinishedEvent::MergeFrom(from._internal_changelocalcachefinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CacheEvent::CopyFrom(const CacheEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.CacheEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CacheEvent::IsInitialized() const {
  return true;
}

void CacheEvent::InternalSwap(CacheEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata CacheEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[33]);
}

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

class CacheErrorEvent::_Internal {
 public:
};

CacheErrorEvent::CacheErrorEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.CacheErrorEvent)
}
CacheErrorEvent::CacheErrorEvent(const CacheErrorEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:grpc.CacheErrorEvent)
}

inline void CacheErrorEvent::SharedCtor() {
type_ = 0;
}

CacheErrorEvent::~CacheErrorEvent() {
  // @@protoc_insertion_point(destructor:grpc.CacheErrorEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void CacheErrorEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CacheErrorEvent::ArenaDtor(void* object) {
  CacheErrorEvent* _this = reinterpret_cast< CacheErrorEvent* >(object);
  (void)_this;
}
void CacheErrorEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CacheErrorEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void CacheErrorEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.CacheErrorEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CacheErrorEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.CacheErrorType type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::grpc::CacheErrorType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CacheErrorEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.CacheErrorEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.CacheErrorType type = 1;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.CacheErrorEvent)
  return target;
}

size_t CacheErrorEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.CacheErrorEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .grpc.CacheErrorType type = 1;
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CacheErrorEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    CacheErrorEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CacheErrorEvent::GetClassData() const { return &_class_data_; }

void CacheErrorEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<CacheErrorEvent *>(to)->MergeFrom(
      static_cast<const CacheErrorEvent &>(from));
}


void CacheErrorEvent::MergeFrom(const CacheErrorEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.CacheErrorEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void CacheErrorEvent::CopyFrom(const CacheErrorEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.CacheErrorEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CacheErrorEvent::IsInitialized() const {
  return true;
}

void CacheErrorEvent::InternalSwap(CacheErrorEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata CacheErrorEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[34]);
}

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

class CacheLocationChangeSuccessEvent::_Internal {
 public:
};

CacheLocationChangeSuccessEvent::CacheLocationChangeSuccessEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.CacheLocationChangeSuccessEvent)
}
CacheLocationChangeSuccessEvent::CacheLocationChangeSuccessEvent(const CacheLocationChangeSuccessEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.CacheLocationChangeSuccessEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CacheLocationChangeSuccessEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CacheLocationChangeSuccessEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata CacheLocationChangeSuccessEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[35]);
}

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

class ChangeLocalCacheFinishedEvent::_Internal {
 public:
};

ChangeLocalCacheFinishedEvent::ChangeLocalCacheFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ChangeLocalCacheFinishedEvent)
}
ChangeLocalCacheFinishedEvent::ChangeLocalCacheFinishedEvent(const ChangeLocalCacheFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ChangeLocalCacheFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChangeLocalCacheFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChangeLocalCacheFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ChangeLocalCacheFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[36]);
}

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

class MailSettingsEvent::_Internal {
 public:
  static const ::grpc::MailSettingsErrorEvent& error(const MailSettingsEvent* msg);
  static const ::grpc::UseSslForSmtpFinishedEvent& usesslforsmtpfinished(const MailSettingsEvent* msg);
  static const ::grpc::ChangePortsFinishedEvent& changeportsfinished(const MailSettingsEvent* msg);
};

const ::grpc::MailSettingsErrorEvent&
MailSettingsEvent::_Internal::error(const MailSettingsEvent* msg) {
  return *msg->event_.error_;
}
const ::grpc::UseSslForSmtpFinishedEvent&
MailSettingsEvent::_Internal::usesslforsmtpfinished(const MailSettingsEvent* msg) {
  return *msg->event_.usesslforsmtpfinished_;
}
const ::grpc::ChangePortsFinishedEvent&
MailSettingsEvent::_Internal::changeportsfinished(const MailSettingsEvent* msg) {
  return *msg->event_.changeportsfinished_;
}
void MailSettingsEvent::set_allocated_error(::grpc::MailSettingsErrorEvent* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::MailSettingsErrorEvent>::GetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    event_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailSettingsEvent.error)
}
void MailSettingsEvent::set_allocated_usesslforsmtpfinished(::grpc::UseSslForSmtpFinishedEvent* usesslforsmtpfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (usesslforsmtpfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UseSslForSmtpFinishedEvent>::GetOwningArena(usesslforsmtpfinished);
    if (message_arena != submessage_arena) {
      usesslforsmtpfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, usesslforsmtpfinished, submessage_arena);
    }
    set_has_usesslforsmtpfinished();
    event_.usesslforsmtpfinished_ = usesslforsmtpfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailSettingsEvent.useSslForSmtpFinished)
}
void MailSettingsEvent::set_allocated_changeportsfinished(::grpc::ChangePortsFinishedEvent* changeportsfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (changeportsfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ChangePortsFinishedEvent>::GetOwningArena(changeportsfinished);
    if (message_arena != submessage_arena) {
      changeportsfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, changeportsfinished, submessage_arena);
    }
    set_has_changeportsfinished();
    event_.changeportsfinished_ = changeportsfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailSettingsEvent.changePortsFinished)
}
MailSettingsEvent::MailSettingsEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.MailSettingsEvent)
}
MailSettingsEvent::MailSettingsEvent(const MailSettingsEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::MailSettingsErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kUseSslForSmtpFinished: {
      _internal_mutable_usesslforsmtpfinished()->::grpc::UseSslForSmtpFinishedEvent::MergeFrom(from._internal_usesslforsmtpfinished());
      break;
    }
    case kChangePortsFinished: {
      _internal_mutable_changeportsfinished()->::grpc::ChangePortsFinishedEvent::MergeFrom(from._internal_changeportsfinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.MailSettingsEvent)
}

inline void MailSettingsEvent::SharedCtor() {
clear_has_event();
}

MailSettingsEvent::~MailSettingsEvent() {
  // @@protoc_insertion_point(destructor:grpc.MailSettingsEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MailSettingsEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void MailSettingsEvent::ArenaDtor(void* object) {
  MailSettingsEvent* _this = reinterpret_cast< MailSettingsEvent* >(object);
  (void)_this;
}
void MailSettingsEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MailSettingsEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MailSettingsEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.MailSettingsEvent)
  switch (event_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.error_;
      }
      break;
    }
    case kUseSslForSmtpFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.usesslforsmtpfinished_;
      }
      break;
    }
    case kChangePortsFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.changeportsfinished_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void MailSettingsEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.MailSettingsEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MailSettingsEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.MailSettingsErrorEvent error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UseSslForSmtpFinishedEvent useSslForSmtpFinished = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_usesslforsmtpfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ChangePortsFinishedEvent changePortsFinished = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changeportsfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MailSettingsEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.MailSettingsEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.MailSettingsErrorEvent error = 1;
  if (_internal_has_error()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::error(this), target, stream);
  }

  // .grpc.UseSslForSmtpFinishedEvent useSslForSmtpFinished = 2;
  if (_internal_has_usesslforsmtpfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::usesslforsmtpfinished(this), target, stream);
  }

  // .grpc.ChangePortsFinishedEvent changePortsFinished = 3;
  if (_internal_has_changeportsfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::changeportsfinished(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.MailSettingsEvent)
  return target;
}

size_t MailSettingsEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.MailSettingsEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.MailSettingsErrorEvent error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.error_);
      break;
    }
    // .grpc.UseSslForSmtpFinishedEvent useSslForSmtpFinished = 2;
    case kUseSslForSmtpFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.usesslforsmtpfinished_);
      break;
    }
    // .grpc.ChangePortsFinishedEvent changePortsFinished = 3;
    case kChangePortsFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.changeportsfinished_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MailSettingsEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MailSettingsEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MailSettingsEvent::GetClassData() const { return &_class_data_; }

void MailSettingsEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<MailSettingsEvent *>(to)->MergeFrom(
      static_cast<const MailSettingsEvent &>(from));
}


void MailSettingsEvent::MergeFrom(const MailSettingsEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.MailSettingsEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kError: {
      _internal_mutable_error()->::grpc::MailSettingsErrorEvent::MergeFrom(from._internal_error());
      break;
    }
    case kUseSslForSmtpFinished: {
      _internal_mutable_usesslforsmtpfinished()->::grpc::UseSslForSmtpFinishedEvent::MergeFrom(from._internal_usesslforsmtpfinished());
      break;
    }
    case kChangePortsFinished: {
      _internal_mutable_changeportsfinished()->::grpc::ChangePortsFinishedEvent::MergeFrom(from._internal_changeportsfinished());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MailSettingsEvent::CopyFrom(const MailSettingsEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.MailSettingsEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MailSettingsEvent::IsInitialized() const {
  return true;
}

void MailSettingsEvent::InternalSwap(MailSettingsEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata MailSettingsEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[37]);
}

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

class MailSettingsErrorEvent::_Internal {
 public:
};

MailSettingsErrorEvent::MailSettingsErrorEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.MailSettingsErrorEvent)
}
MailSettingsErrorEvent::MailSettingsErrorEvent(const MailSettingsErrorEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:grpc.MailSettingsErrorEvent)
}

inline void MailSettingsErrorEvent::SharedCtor() {
type_ = 0;
}

MailSettingsErrorEvent::~MailSettingsErrorEvent() {
  // @@protoc_insertion_point(destructor:grpc.MailSettingsErrorEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MailSettingsErrorEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MailSettingsErrorEvent::ArenaDtor(void* object) {
  MailSettingsErrorEvent* _this = reinterpret_cast< MailSettingsErrorEvent* >(object);
  (void)_this;
}
void MailSettingsErrorEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MailSettingsErrorEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MailSettingsErrorEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.MailSettingsErrorEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  type_ = 0;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MailSettingsErrorEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.MailSettingsErrorType type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::grpc::MailSettingsErrorType>(val));
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MailSettingsErrorEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.MailSettingsErrorEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.MailSettingsErrorType type = 1;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.MailSettingsErrorEvent)
  return target;
}

size_t MailSettingsErrorEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.MailSettingsErrorEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .grpc.MailSettingsErrorType type = 1;
  if (this->_internal_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MailSettingsErrorEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MailSettingsErrorEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MailSettingsErrorEvent::GetClassData() const { return &_class_data_; }

void MailSettingsErrorEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<MailSettingsErrorEvent *>(to)->MergeFrom(
      static_cast<const MailSettingsErrorEvent &>(from));
}


void MailSettingsErrorEvent::MergeFrom(const MailSettingsErrorEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.MailSettingsErrorEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_type() != 0) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MailSettingsErrorEvent::CopyFrom(const MailSettingsErrorEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.MailSettingsErrorEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MailSettingsErrorEvent::IsInitialized() const {
  return true;
}

void MailSettingsErrorEvent::InternalSwap(MailSettingsErrorEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MailSettingsErrorEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[38]);
}

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

class UseSslForSmtpFinishedEvent::_Internal {
 public:
};

UseSslForSmtpFinishedEvent::UseSslForSmtpFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.UseSslForSmtpFinishedEvent)
}
UseSslForSmtpFinishedEvent::UseSslForSmtpFinishedEvent(const UseSslForSmtpFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.UseSslForSmtpFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UseSslForSmtpFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UseSslForSmtpFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata UseSslForSmtpFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[39]);
}

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

class ChangePortsFinishedEvent::_Internal {
 public:
};

ChangePortsFinishedEvent::ChangePortsFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ChangePortsFinishedEvent)
}
ChangePortsFinishedEvent::ChangePortsFinishedEvent(const ChangePortsFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ChangePortsFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChangePortsFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChangePortsFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ChangePortsFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[40]);
}

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

class KeychainEvent::_Internal {
 public:
  static const ::grpc::ChangeKeychainFinishedEvent& changekeychainfinished(const KeychainEvent* msg);
  static const ::grpc::HasNoKeychainEvent& hasnokeychain(const KeychainEvent* msg);
  static const ::grpc::RebuildKeychainEvent& rebuildkeychain(const KeychainEvent* msg);
};

const ::grpc::ChangeKeychainFinishedEvent&
KeychainEvent::_Internal::changekeychainfinished(const KeychainEvent* msg) {
  return *msg->event_.changekeychainfinished_;
}
const ::grpc::HasNoKeychainEvent&
KeychainEvent::_Internal::hasnokeychain(const KeychainEvent* msg) {
  return *msg->event_.hasnokeychain_;
}
const ::grpc::RebuildKeychainEvent&
KeychainEvent::_Internal::rebuildkeychain(const KeychainEvent* msg) {
  return *msg->event_.rebuildkeychain_;
}
void KeychainEvent::set_allocated_changekeychainfinished(::grpc::ChangeKeychainFinishedEvent* changekeychainfinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (changekeychainfinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ChangeKeychainFinishedEvent>::GetOwningArena(changekeychainfinished);
    if (message_arena != submessage_arena) {
      changekeychainfinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, changekeychainfinished, submessage_arena);
    }
    set_has_changekeychainfinished();
    event_.changekeychainfinished_ = changekeychainfinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.KeychainEvent.changeKeychainFinished)
}
void KeychainEvent::set_allocated_hasnokeychain(::grpc::HasNoKeychainEvent* hasnokeychain) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (hasnokeychain) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::HasNoKeychainEvent>::GetOwningArena(hasnokeychain);
    if (message_arena != submessage_arena) {
      hasnokeychain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hasnokeychain, submessage_arena);
    }
    set_has_hasnokeychain();
    event_.hasnokeychain_ = hasnokeychain;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.KeychainEvent.hasNoKeychain)
}
void KeychainEvent::set_allocated_rebuildkeychain(::grpc::RebuildKeychainEvent* rebuildkeychain) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (rebuildkeychain) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::RebuildKeychainEvent>::GetOwningArena(rebuildkeychain);
    if (message_arena != submessage_arena) {
      rebuildkeychain = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, rebuildkeychain, submessage_arena);
    }
    set_has_rebuildkeychain();
    event_.rebuildkeychain_ = rebuildkeychain;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.KeychainEvent.rebuildKeychain)
}
KeychainEvent::KeychainEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.KeychainEvent)
}
KeychainEvent::KeychainEvent(const KeychainEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kChangeKeychainFinished: {
      _internal_mutable_changekeychainfinished()->::grpc::ChangeKeychainFinishedEvent::MergeFrom(from._internal_changekeychainfinished());
      break;
    }
    case kHasNoKeychain: {
      _internal_mutable_hasnokeychain()->::grpc::HasNoKeychainEvent::MergeFrom(from._internal_hasnokeychain());
      break;
    }
    case kRebuildKeychain: {
      _internal_mutable_rebuildkeychain()->::grpc::RebuildKeychainEvent::MergeFrom(from._internal_rebuildkeychain());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.KeychainEvent)
}

inline void KeychainEvent::SharedCtor() {
clear_has_event();
}

KeychainEvent::~KeychainEvent() {
  // @@protoc_insertion_point(destructor:grpc.KeychainEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void KeychainEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void KeychainEvent::ArenaDtor(void* object) {
  KeychainEvent* _this = reinterpret_cast< KeychainEvent* >(object);
  (void)_this;
}
void KeychainEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void KeychainEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void KeychainEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.KeychainEvent)
  switch (event_case()) {
    case kChangeKeychainFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.changekeychainfinished_;
      }
      break;
    }
    case kHasNoKeychain: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.hasnokeychain_;
      }
      break;
    }
    case kRebuildKeychain: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.rebuildkeychain_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void KeychainEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.KeychainEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* KeychainEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.ChangeKeychainFinishedEvent changeKeychainFinished = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_changekeychainfinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.HasNoKeychainEvent hasNoKeychain = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_hasnokeychain(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.RebuildKeychainEvent rebuildKeychain = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_rebuildkeychain(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* KeychainEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.KeychainEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.ChangeKeychainFinishedEvent changeKeychainFinished = 1;
  if (_internal_has_changekeychainfinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::changekeychainfinished(this), target, stream);
  }

  // .grpc.HasNoKeychainEvent hasNoKeychain = 2;
  if (_internal_has_hasnokeychain()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::hasnokeychain(this), target, stream);
  }

  // .grpc.RebuildKeychainEvent rebuildKeychain = 3;
  if (_internal_has_rebuildkeychain()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::rebuildkeychain(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.KeychainEvent)
  return target;
}

size_t KeychainEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.KeychainEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.ChangeKeychainFinishedEvent changeKeychainFinished = 1;
    case kChangeKeychainFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.changekeychainfinished_);
      break;
    }
    // .grpc.HasNoKeychainEvent hasNoKeychain = 2;
    case kHasNoKeychain: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.hasnokeychain_);
      break;
    }
    // .grpc.RebuildKeychainEvent rebuildKeychain = 3;
    case kRebuildKeychain: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.rebuildkeychain_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData KeychainEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    KeychainEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*KeychainEvent::GetClassData() const { return &_class_data_; }

void KeychainEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<KeychainEvent *>(to)->MergeFrom(
      static_cast<const KeychainEvent &>(from));
}


void KeychainEvent::MergeFrom(const KeychainEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.KeychainEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kChangeKeychainFinished: {
      _internal_mutable_changekeychainfinished()->::grpc::ChangeKeychainFinishedEvent::MergeFrom(from._internal_changekeychainfinished());
      break;
    }
    case kHasNoKeychain: {
      _internal_mutable_hasnokeychain()->::grpc::HasNoKeychainEvent::MergeFrom(from._internal_hasnokeychain());
      break;
    }
    case kRebuildKeychain: {
      _internal_mutable_rebuildkeychain()->::grpc::RebuildKeychainEvent::MergeFrom(from._internal_rebuildkeychain());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void KeychainEvent::CopyFrom(const KeychainEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.KeychainEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KeychainEvent::IsInitialized() const {
  return true;
}

void KeychainEvent::InternalSwap(KeychainEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata KeychainEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[41]);
}

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

class ChangeKeychainFinishedEvent::_Internal {
 public:
};

ChangeKeychainFinishedEvent::ChangeKeychainFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ChangeKeychainFinishedEvent)
}
ChangeKeychainFinishedEvent::ChangeKeychainFinishedEvent(const ChangeKeychainFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ChangeKeychainFinishedEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ChangeKeychainFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ChangeKeychainFinishedEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ChangeKeychainFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[42]);
}

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

class HasNoKeychainEvent::_Internal {
 public:
};

HasNoKeychainEvent::HasNoKeychainEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.HasNoKeychainEvent)
}
HasNoKeychainEvent::HasNoKeychainEvent(const HasNoKeychainEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.HasNoKeychainEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData HasNoKeychainEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*HasNoKeychainEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata HasNoKeychainEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[43]);
}

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

class RebuildKeychainEvent::_Internal {
 public:
};

RebuildKeychainEvent::RebuildKeychainEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.RebuildKeychainEvent)
}
RebuildKeychainEvent::RebuildKeychainEvent(const RebuildKeychainEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.RebuildKeychainEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RebuildKeychainEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RebuildKeychainEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata RebuildKeychainEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[44]);
}

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

class MailEvent::_Internal {
 public:
  static const ::grpc::NoActiveKeyForRecipientEvent& noactivekeyforrecipientevent(const MailEvent* msg);
  static const ::grpc::AddressChangedEvent& addresschanged(const MailEvent* msg);
  static const ::grpc::AddressChangedLogoutEvent& addresschangedlogout(const MailEvent* msg);
  static const ::grpc::ApiCertIssueEvent& apicertissue(const MailEvent* msg);
};

const ::grpc::NoActiveKeyForRecipientEvent&
MailEvent::_Internal::noactivekeyforrecipientevent(const MailEvent* msg) {
  return *msg->event_.noactivekeyforrecipientevent_;
}
const ::grpc::AddressChangedEvent&
MailEvent::_Internal::addresschanged(const MailEvent* msg) {
  return *msg->event_.addresschanged_;
}
const ::grpc::AddressChangedLogoutEvent&
MailEvent::_Internal::addresschangedlogout(const MailEvent* msg) {
  return *msg->event_.addresschangedlogout_;
}
const ::grpc::ApiCertIssueEvent&
MailEvent::_Internal::apicertissue(const MailEvent* msg) {
  return *msg->event_.apicertissue_;
}
void MailEvent::set_allocated_noactivekeyforrecipientevent(::grpc::NoActiveKeyForRecipientEvent* noactivekeyforrecipientevent) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (noactivekeyforrecipientevent) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::NoActiveKeyForRecipientEvent>::GetOwningArena(noactivekeyforrecipientevent);
    if (message_arena != submessage_arena) {
      noactivekeyforrecipientevent = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, noactivekeyforrecipientevent, submessage_arena);
    }
    set_has_noactivekeyforrecipientevent();
    event_.noactivekeyforrecipientevent_ = noactivekeyforrecipientevent;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailEvent.noActiveKeyForRecipientEvent)
}
void MailEvent::set_allocated_addresschanged(::grpc::AddressChangedEvent* addresschanged) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (addresschanged) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::AddressChangedEvent>::GetOwningArena(addresschanged);
    if (message_arena != submessage_arena) {
      addresschanged = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, addresschanged, submessage_arena);
    }
    set_has_addresschanged();
    event_.addresschanged_ = addresschanged;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailEvent.addressChanged)
}
void MailEvent::set_allocated_addresschangedlogout(::grpc::AddressChangedLogoutEvent* addresschangedlogout) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (addresschangedlogout) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::AddressChangedLogoutEvent>::GetOwningArena(addresschangedlogout);
    if (message_arena != submessage_arena) {
      addresschangedlogout = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, addresschangedlogout, submessage_arena);
    }
    set_has_addresschangedlogout();
    event_.addresschangedlogout_ = addresschangedlogout;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailEvent.addressChangedLogout)
}
void MailEvent::set_allocated_apicertissue(::grpc::ApiCertIssueEvent* apicertissue) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (apicertissue) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ApiCertIssueEvent>::GetOwningArena(apicertissue);
    if (message_arena != submessage_arena) {
      apicertissue = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, apicertissue, submessage_arena);
    }
    set_has_apicertissue();
    event_.apicertissue_ = apicertissue;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.MailEvent.apiCertIssue)
}
MailEvent::MailEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.MailEvent)
}
MailEvent::MailEvent(const MailEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kNoActiveKeyForRecipientEvent: {
      _internal_mutable_noactivekeyforrecipientevent()->::grpc::NoActiveKeyForRecipientEvent::MergeFrom(from._internal_noactivekeyforrecipientevent());
      break;
    }
    case kAddressChanged: {
      _internal_mutable_addresschanged()->::grpc::AddressChangedEvent::MergeFrom(from._internal_addresschanged());
      break;
    }
    case kAddressChangedLogout: {
      _internal_mutable_addresschangedlogout()->::grpc::AddressChangedLogoutEvent::MergeFrom(from._internal_addresschangedlogout());
      break;
    }
    case kApiCertIssue: {
      _internal_mutable_apicertissue()->::grpc::ApiCertIssueEvent::MergeFrom(from._internal_apicertissue());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.MailEvent)
}

inline void MailEvent::SharedCtor() {
clear_has_event();
}

MailEvent::~MailEvent() {
  // @@protoc_insertion_point(destructor:grpc.MailEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MailEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void MailEvent::ArenaDtor(void* object) {
  MailEvent* _this = reinterpret_cast< MailEvent* >(object);
  (void)_this;
}
void MailEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MailEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MailEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.MailEvent)
  switch (event_case()) {
    case kNoActiveKeyForRecipientEvent: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.noactivekeyforrecipientevent_;
      }
      break;
    }
    case kAddressChanged: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.addresschanged_;
      }
      break;
    }
    case kAddressChangedLogout: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.addresschangedlogout_;
      }
      break;
    }
    case kApiCertIssue: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.apicertissue_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void MailEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.MailEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MailEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.NoActiveKeyForRecipientEvent noActiveKeyForRecipientEvent = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_noactivekeyforrecipientevent(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.AddressChangedEvent addressChanged = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_addresschanged(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.AddressChangedLogoutEvent addressChangedLogout = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_addresschangedlogout(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.ApiCertIssueEvent apiCertIssue = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_apicertissue(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* MailEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.MailEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.NoActiveKeyForRecipientEvent noActiveKeyForRecipientEvent = 1;
  if (_internal_has_noactivekeyforrecipientevent()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::noactivekeyforrecipientevent(this), target, stream);
  }

  // .grpc.AddressChangedEvent addressChanged = 2;
  if (_internal_has_addresschanged()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::addresschanged(this), target, stream);
  }

  // .grpc.AddressChangedLogoutEvent addressChangedLogout = 3;
  if (_internal_has_addresschangedlogout()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::addresschangedlogout(this), target, stream);
  }

  // .grpc.ApiCertIssueEvent apiCertIssue = 6;
  if (_internal_has_apicertissue()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::apicertissue(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.MailEvent)
  return target;
}

size_t MailEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.MailEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.NoActiveKeyForRecipientEvent noActiveKeyForRecipientEvent = 1;
    case kNoActiveKeyForRecipientEvent: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.noactivekeyforrecipientevent_);
      break;
    }
    // .grpc.AddressChangedEvent addressChanged = 2;
    case kAddressChanged: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.addresschanged_);
      break;
    }
    // .grpc.AddressChangedLogoutEvent addressChangedLogout = 3;
    case kAddressChangedLogout: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.addresschangedlogout_);
      break;
    }
    // .grpc.ApiCertIssueEvent apiCertIssue = 6;
    case kApiCertIssue: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.apicertissue_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MailEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MailEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MailEvent::GetClassData() const { return &_class_data_; }

void MailEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<MailEvent *>(to)->MergeFrom(
      static_cast<const MailEvent &>(from));
}


void MailEvent::MergeFrom(const MailEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.MailEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kNoActiveKeyForRecipientEvent: {
      _internal_mutable_noactivekeyforrecipientevent()->::grpc::NoActiveKeyForRecipientEvent::MergeFrom(from._internal_noactivekeyforrecipientevent());
      break;
    }
    case kAddressChanged: {
      _internal_mutable_addresschanged()->::grpc::AddressChangedEvent::MergeFrom(from._internal_addresschanged());
      break;
    }
    case kAddressChangedLogout: {
      _internal_mutable_addresschangedlogout()->::grpc::AddressChangedLogoutEvent::MergeFrom(from._internal_addresschangedlogout());
      break;
    }
    case kApiCertIssue: {
      _internal_mutable_apicertissue()->::grpc::ApiCertIssueEvent::MergeFrom(from._internal_apicertissue());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MailEvent::CopyFrom(const MailEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.MailEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MailEvent::IsInitialized() const {
  return true;
}

void MailEvent::InternalSwap(MailEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata MailEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[45]);
}

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

class NoActiveKeyForRecipientEvent::_Internal {
 public:
};

NoActiveKeyForRecipientEvent::NoActiveKeyForRecipientEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.NoActiveKeyForRecipientEvent)
}
NoActiveKeyForRecipientEvent::NoActiveKeyForRecipientEvent(const NoActiveKeyForRecipientEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_email().empty()) {
    email_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_email(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.NoActiveKeyForRecipientEvent)
}

inline void NoActiveKeyForRecipientEvent::SharedCtor() {
email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

NoActiveKeyForRecipientEvent::~NoActiveKeyForRecipientEvent() {
  // @@protoc_insertion_point(destructor:grpc.NoActiveKeyForRecipientEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void NoActiveKeyForRecipientEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  email_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void NoActiveKeyForRecipientEvent::ArenaDtor(void* object) {
  NoActiveKeyForRecipientEvent* _this = reinterpret_cast< NoActiveKeyForRecipientEvent* >(object);
  (void)_this;
}
void NoActiveKeyForRecipientEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void NoActiveKeyForRecipientEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void NoActiveKeyForRecipientEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.NoActiveKeyForRecipientEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  email_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* NoActiveKeyForRecipientEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string email = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_email();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.NoActiveKeyForRecipientEvent.email"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* NoActiveKeyForRecipientEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.NoActiveKeyForRecipientEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string email = 1;
  if (!this->_internal_email().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_email().data(), static_cast<int>(this->_internal_email().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.NoActiveKeyForRecipientEvent.email");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_email(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.NoActiveKeyForRecipientEvent)
  return target;
}

size_t NoActiveKeyForRecipientEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.NoActiveKeyForRecipientEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string email = 1;
  if (!this->_internal_email().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_email());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NoActiveKeyForRecipientEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    NoActiveKeyForRecipientEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NoActiveKeyForRecipientEvent::GetClassData() const { return &_class_data_; }

void NoActiveKeyForRecipientEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<NoActiveKeyForRecipientEvent *>(to)->MergeFrom(
      static_cast<const NoActiveKeyForRecipientEvent &>(from));
}


void NoActiveKeyForRecipientEvent::MergeFrom(const NoActiveKeyForRecipientEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.NoActiveKeyForRecipientEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_email().empty()) {
    _internal_set_email(from._internal_email());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void NoActiveKeyForRecipientEvent::CopyFrom(const NoActiveKeyForRecipientEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.NoActiveKeyForRecipientEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool NoActiveKeyForRecipientEvent::IsInitialized() const {
  return true;
}

void NoActiveKeyForRecipientEvent::InternalSwap(NoActiveKeyForRecipientEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &email_, lhs_arena,
      &other->email_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata NoActiveKeyForRecipientEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[46]);
}

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

class AddressChangedEvent::_Internal {
 public:
};

AddressChangedEvent::AddressChangedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.AddressChangedEvent)
}
AddressChangedEvent::AddressChangedEvent(const AddressChangedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_address().empty()) {
    address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_address(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.AddressChangedEvent)
}

inline void AddressChangedEvent::SharedCtor() {
address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

AddressChangedEvent::~AddressChangedEvent() {
  // @@protoc_insertion_point(destructor:grpc.AddressChangedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AddressChangedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void AddressChangedEvent::ArenaDtor(void* object) {
  AddressChangedEvent* _this = reinterpret_cast< AddressChangedEvent* >(object);
  (void)_this;
}
void AddressChangedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AddressChangedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AddressChangedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.AddressChangedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  address_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AddressChangedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string address = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.AddressChangedEvent.address"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* AddressChangedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.AddressChangedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string address = 1;
  if (!this->_internal_address().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_address().data(), static_cast<int>(this->_internal_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.AddressChangedEvent.address");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_address(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.AddressChangedEvent)
  return target;
}

size_t AddressChangedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.AddressChangedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string address = 1;
  if (!this->_internal_address().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_address());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AddressChangedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AddressChangedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AddressChangedEvent::GetClassData() const { return &_class_data_; }

void AddressChangedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AddressChangedEvent *>(to)->MergeFrom(
      static_cast<const AddressChangedEvent &>(from));
}


void AddressChangedEvent::MergeFrom(const AddressChangedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.AddressChangedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_address().empty()) {
    _internal_set_address(from._internal_address());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AddressChangedEvent::CopyFrom(const AddressChangedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.AddressChangedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AddressChangedEvent::IsInitialized() const {
  return true;
}

void AddressChangedEvent::InternalSwap(AddressChangedEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &address_, lhs_arena,
      &other->address_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata AddressChangedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[47]);
}

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

class AddressChangedLogoutEvent::_Internal {
 public:
};

AddressChangedLogoutEvent::AddressChangedLogoutEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.AddressChangedLogoutEvent)
}
AddressChangedLogoutEvent::AddressChangedLogoutEvent(const AddressChangedLogoutEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_address().empty()) {
    address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_address(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.AddressChangedLogoutEvent)
}

inline void AddressChangedLogoutEvent::SharedCtor() {
address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

AddressChangedLogoutEvent::~AddressChangedLogoutEvent() {
  // @@protoc_insertion_point(destructor:grpc.AddressChangedLogoutEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void AddressChangedLogoutEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void AddressChangedLogoutEvent::ArenaDtor(void* object) {
  AddressChangedLogoutEvent* _this = reinterpret_cast< AddressChangedLogoutEvent* >(object);
  (void)_this;
}
void AddressChangedLogoutEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AddressChangedLogoutEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void AddressChangedLogoutEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.AddressChangedLogoutEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  address_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* AddressChangedLogoutEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string address = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_address();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.AddressChangedLogoutEvent.address"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* AddressChangedLogoutEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.AddressChangedLogoutEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string address = 1;
  if (!this->_internal_address().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_address().data(), static_cast<int>(this->_internal_address().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.AddressChangedLogoutEvent.address");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_address(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.AddressChangedLogoutEvent)
  return target;
}

size_t AddressChangedLogoutEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.AddressChangedLogoutEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string address = 1;
  if (!this->_internal_address().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_address());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AddressChangedLogoutEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    AddressChangedLogoutEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AddressChangedLogoutEvent::GetClassData() const { return &_class_data_; }

void AddressChangedLogoutEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<AddressChangedLogoutEvent *>(to)->MergeFrom(
      static_cast<const AddressChangedLogoutEvent &>(from));
}


void AddressChangedLogoutEvent::MergeFrom(const AddressChangedLogoutEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.AddressChangedLogoutEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_address().empty()) {
    _internal_set_address(from._internal_address());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void AddressChangedLogoutEvent::CopyFrom(const AddressChangedLogoutEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.AddressChangedLogoutEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AddressChangedLogoutEvent::IsInitialized() const {
  return true;
}

void AddressChangedLogoutEvent::InternalSwap(AddressChangedLogoutEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &address_, lhs_arena,
      &other->address_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata AddressChangedLogoutEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[48]);
}

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

class ApiCertIssueEvent::_Internal {
 public:
};

ApiCertIssueEvent::ApiCertIssueEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) {
  // @@protoc_insertion_point(arena_constructor:grpc.ApiCertIssueEvent)
}
ApiCertIssueEvent::ApiCertIssueEvent(const ApiCertIssueEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:grpc.ApiCertIssueEvent)
}





const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ApiCertIssueEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl,
    ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl,
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ApiCertIssueEvent::GetClassData() const { return &_class_data_; }







::PROTOBUF_NAMESPACE_ID::Metadata ApiCertIssueEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[49]);
}

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

class UserEvent::_Internal {
 public:
  static const ::grpc::ToggleSplitModeFinishedEvent& togglesplitmodefinished(const UserEvent* msg);
  static const ::grpc::UserDisconnectedEvent& userdisconnected(const UserEvent* msg);
  static const ::grpc::UserChangedEvent& userchanged(const UserEvent* msg);
};

const ::grpc::ToggleSplitModeFinishedEvent&
UserEvent::_Internal::togglesplitmodefinished(const UserEvent* msg) {
  return *msg->event_.togglesplitmodefinished_;
}
const ::grpc::UserDisconnectedEvent&
UserEvent::_Internal::userdisconnected(const UserEvent* msg) {
  return *msg->event_.userdisconnected_;
}
const ::grpc::UserChangedEvent&
UserEvent::_Internal::userchanged(const UserEvent* msg) {
  return *msg->event_.userchanged_;
}
void UserEvent::set_allocated_togglesplitmodefinished(::grpc::ToggleSplitModeFinishedEvent* togglesplitmodefinished) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (togglesplitmodefinished) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::ToggleSplitModeFinishedEvent>::GetOwningArena(togglesplitmodefinished);
    if (message_arena != submessage_arena) {
      togglesplitmodefinished = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, togglesplitmodefinished, submessage_arena);
    }
    set_has_togglesplitmodefinished();
    event_.togglesplitmodefinished_ = togglesplitmodefinished;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UserEvent.toggleSplitModeFinished)
}
void UserEvent::set_allocated_userdisconnected(::grpc::UserDisconnectedEvent* userdisconnected) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (userdisconnected) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UserDisconnectedEvent>::GetOwningArena(userdisconnected);
    if (message_arena != submessage_arena) {
      userdisconnected = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, userdisconnected, submessage_arena);
    }
    set_has_userdisconnected();
    event_.userdisconnected_ = userdisconnected;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UserEvent.userDisconnected)
}
void UserEvent::set_allocated_userchanged(::grpc::UserChangedEvent* userchanged) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_event();
  if (userchanged) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::grpc::UserChangedEvent>::GetOwningArena(userchanged);
    if (message_arena != submessage_arena) {
      userchanged = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, userchanged, submessage_arena);
    }
    set_has_userchanged();
    event_.userchanged_ = userchanged;
  }
  // @@protoc_insertion_point(field_set_allocated:grpc.UserEvent.userChanged)
}
UserEvent::UserEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UserEvent)
}
UserEvent::UserEvent(const UserEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_event();
  switch (from.event_case()) {
    case kToggleSplitModeFinished: {
      _internal_mutable_togglesplitmodefinished()->::grpc::ToggleSplitModeFinishedEvent::MergeFrom(from._internal_togglesplitmodefinished());
      break;
    }
    case kUserDisconnected: {
      _internal_mutable_userdisconnected()->::grpc::UserDisconnectedEvent::MergeFrom(from._internal_userdisconnected());
      break;
    }
    case kUserChanged: {
      _internal_mutable_userchanged()->::grpc::UserChangedEvent::MergeFrom(from._internal_userchanged());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UserEvent)
}

inline void UserEvent::SharedCtor() {
clear_has_event();
}

UserEvent::~UserEvent() {
  // @@protoc_insertion_point(destructor:grpc.UserEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UserEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_event()) {
    clear_event();
  }
}

void UserEvent::ArenaDtor(void* object) {
  UserEvent* _this = reinterpret_cast< UserEvent* >(object);
  (void)_this;
}
void UserEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UserEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UserEvent::clear_event() {
// @@protoc_insertion_point(one_of_clear_start:grpc.UserEvent)
  switch (event_case()) {
    case kToggleSplitModeFinished: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.togglesplitmodefinished_;
      }
      break;
    }
    case kUserDisconnected: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.userdisconnected_;
      }
      break;
    }
    case kUserChanged: {
      if (GetArenaForAllocation() == nullptr) {
        delete event_.userchanged_;
      }
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = EVENT_NOT_SET;
}


void UserEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UserEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_event();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UserEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.ToggleSplitModeFinishedEvent toggleSplitModeFinished = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_togglesplitmodefinished(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UserDisconnectedEvent userDisconnected = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_userdisconnected(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // .grpc.UserChangedEvent userChanged = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_userchanged(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UserEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UserEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.ToggleSplitModeFinishedEvent toggleSplitModeFinished = 1;
  if (_internal_has_togglesplitmodefinished()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::togglesplitmodefinished(this), target, stream);
  }

  // .grpc.UserDisconnectedEvent userDisconnected = 2;
  if (_internal_has_userdisconnected()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::userdisconnected(this), target, stream);
  }

  // .grpc.UserChangedEvent userChanged = 3;
  if (_internal_has_userchanged()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::userchanged(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UserEvent)
  return target;
}

size_t UserEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UserEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (event_case()) {
    // .grpc.ToggleSplitModeFinishedEvent toggleSplitModeFinished = 1;
    case kToggleSplitModeFinished: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.togglesplitmodefinished_);
      break;
    }
    // .grpc.UserDisconnectedEvent userDisconnected = 2;
    case kUserDisconnected: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.userdisconnected_);
      break;
    }
    // .grpc.UserChangedEvent userChanged = 3;
    case kUserChanged: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *event_.userchanged_);
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UserEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserEvent::GetClassData() const { return &_class_data_; }

void UserEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UserEvent *>(to)->MergeFrom(
      static_cast<const UserEvent &>(from));
}


void UserEvent::MergeFrom(const UserEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UserEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.event_case()) {
    case kToggleSplitModeFinished: {
      _internal_mutable_togglesplitmodefinished()->::grpc::ToggleSplitModeFinishedEvent::MergeFrom(from._internal_togglesplitmodefinished());
      break;
    }
    case kUserDisconnected: {
      _internal_mutable_userdisconnected()->::grpc::UserDisconnectedEvent::MergeFrom(from._internal_userdisconnected());
      break;
    }
    case kUserChanged: {
      _internal_mutable_userchanged()->::grpc::UserChangedEvent::MergeFrom(from._internal_userchanged());
      break;
    }
    case EVENT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UserEvent::CopyFrom(const UserEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UserEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserEvent::IsInitialized() const {
  return true;
}

void UserEvent::InternalSwap(UserEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(event_, other->event_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata UserEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[50]);
}

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

class ToggleSplitModeFinishedEvent::_Internal {
 public:
};

ToggleSplitModeFinishedEvent::ToggleSplitModeFinishedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.ToggleSplitModeFinishedEvent)
}
ToggleSplitModeFinishedEvent::ToggleSplitModeFinishedEvent(const ToggleSplitModeFinishedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_userid().empty()) {
    userid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_userid(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.ToggleSplitModeFinishedEvent)
}

inline void ToggleSplitModeFinishedEvent::SharedCtor() {
userid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  userid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

ToggleSplitModeFinishedEvent::~ToggleSplitModeFinishedEvent() {
  // @@protoc_insertion_point(destructor:grpc.ToggleSplitModeFinishedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void ToggleSplitModeFinishedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  userid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void ToggleSplitModeFinishedEvent::ArenaDtor(void* object) {
  ToggleSplitModeFinishedEvent* _this = reinterpret_cast< ToggleSplitModeFinishedEvent* >(object);
  (void)_this;
}
void ToggleSplitModeFinishedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void ToggleSplitModeFinishedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void ToggleSplitModeFinishedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.ToggleSplitModeFinishedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  userid_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ToggleSplitModeFinishedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string userID = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_userid();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.ToggleSplitModeFinishedEvent.userID"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* ToggleSplitModeFinishedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.ToggleSplitModeFinishedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_userid().data(), static_cast<int>(this->_internal_userid().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.ToggleSplitModeFinishedEvent.userID");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_userid(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.ToggleSplitModeFinishedEvent)
  return target;
}

size_t ToggleSplitModeFinishedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.ToggleSplitModeFinishedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string userID = 1;
  if (!this->_internal_userid().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_userid());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ToggleSplitModeFinishedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    ToggleSplitModeFinishedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ToggleSplitModeFinishedEvent::GetClassData() const { return &_class_data_; }

void ToggleSplitModeFinishedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<ToggleSplitModeFinishedEvent *>(to)->MergeFrom(
      static_cast<const ToggleSplitModeFinishedEvent &>(from));
}


void ToggleSplitModeFinishedEvent::MergeFrom(const ToggleSplitModeFinishedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.ToggleSplitModeFinishedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_userid().empty()) {
    _internal_set_userid(from._internal_userid());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void ToggleSplitModeFinishedEvent::CopyFrom(const ToggleSplitModeFinishedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.ToggleSplitModeFinishedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ToggleSplitModeFinishedEvent::IsInitialized() const {
  return true;
}

void ToggleSplitModeFinishedEvent::InternalSwap(ToggleSplitModeFinishedEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &userid_, lhs_arena,
      &other->userid_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata ToggleSplitModeFinishedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[51]);
}

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

class UserDisconnectedEvent::_Internal {
 public:
};

UserDisconnectedEvent::UserDisconnectedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UserDisconnectedEvent)
}
UserDisconnectedEvent::UserDisconnectedEvent(const UserDisconnectedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_username().empty()) {
    username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UserDisconnectedEvent)
}

inline void UserDisconnectedEvent::SharedCtor() {
username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

UserDisconnectedEvent::~UserDisconnectedEvent() {
  // @@protoc_insertion_point(destructor:grpc.UserDisconnectedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UserDisconnectedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void UserDisconnectedEvent::ArenaDtor(void* object) {
  UserDisconnectedEvent* _this = reinterpret_cast< UserDisconnectedEvent* >(object);
  (void)_this;
}
void UserDisconnectedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UserDisconnectedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UserDisconnectedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UserDisconnectedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  username_.ClearToEmpty();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UserDisconnectedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string username = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_username();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "grpc.UserDisconnectedEvent.username"));
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UserDisconnectedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UserDisconnectedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
      this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
      "grpc.UserDisconnectedEvent.username");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_username(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UserDisconnectedEvent)
  return target;
}

size_t UserDisconnectedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UserDisconnectedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // string username = 1;
  if (!this->_internal_username().empty()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_username());
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserDisconnectedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UserDisconnectedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserDisconnectedEvent::GetClassData() const { return &_class_data_; }

void UserDisconnectedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UserDisconnectedEvent *>(to)->MergeFrom(
      static_cast<const UserDisconnectedEvent &>(from));
}


void UserDisconnectedEvent::MergeFrom(const UserDisconnectedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UserDisconnectedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_username().empty()) {
    _internal_set_username(from._internal_username());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UserDisconnectedEvent::CopyFrom(const UserDisconnectedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UserDisconnectedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserDisconnectedEvent::IsInitialized() const {
  return true;
}

void UserDisconnectedEvent::InternalSwap(UserDisconnectedEvent* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &username_, lhs_arena,
      &other->username_, rhs_arena
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata UserDisconnectedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[52]);
}

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

class UserChangedEvent::_Internal {
 public:
  static const ::grpc::User& user(const UserChangedEvent* msg);
};

const ::grpc::User&
UserChangedEvent::_Internal::user(const UserChangedEvent* msg) {
  return *msg->user_;
}
UserChangedEvent::UserChangedEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:grpc.UserChangedEvent)
}
UserChangedEvent::UserChangedEvent(const UserChangedEvent& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_user()) {
    user_ = new ::grpc::User(*from.user_);
  } else {
    user_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:grpc.UserChangedEvent)
}

inline void UserChangedEvent::SharedCtor() {
user_ = nullptr;
}

UserChangedEvent::~UserChangedEvent() {
  // @@protoc_insertion_point(destructor:grpc.UserChangedEvent)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void UserChangedEvent::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete user_;
}

void UserChangedEvent::ArenaDtor(void* object) {
  UserChangedEvent* _this = reinterpret_cast< UserChangedEvent* >(object);
  (void)_this;
}
void UserChangedEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void UserChangedEvent::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void UserChangedEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:grpc.UserChangedEvent)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (GetArenaForAllocation() == nullptr && user_ != nullptr) {
    delete user_;
  }
  user_ = nullptr;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* UserChangedEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .grpc.User user = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_user(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* UserChangedEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:grpc.UserChangedEvent)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .grpc.User user = 1;
  if (this->_internal_has_user()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::user(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:grpc.UserChangedEvent)
  return target;
}

size_t UserChangedEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:grpc.UserChangedEvent)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .grpc.User user = 1;
  if (this->_internal_has_user()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *user_);
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData UserChangedEvent::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    UserChangedEvent::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*UserChangedEvent::GetClassData() const { return &_class_data_; }

void UserChangedEvent::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<UserChangedEvent *>(to)->MergeFrom(
      static_cast<const UserChangedEvent &>(from));
}


void UserChangedEvent::MergeFrom(const UserChangedEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:grpc.UserChangedEvent)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_user()) {
    _internal_mutable_user()->::grpc::User::MergeFrom(from._internal_user());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void UserChangedEvent::CopyFrom(const UserChangedEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:grpc.UserChangedEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool UserChangedEvent::IsInitialized() const {
  return true;
}

void UserChangedEvent::InternalSwap(UserChangedEvent* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(user_, other->user_);
}

::PROTOBUF_NAMESPACE_ID::Metadata UserChangedEvent::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_bridge_2eproto_getter, &descriptor_table_bridge_2eproto_once,
      file_level_metadata_bridge_2eproto[53]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace grpc
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::grpc::PointResponse* Arena::CreateMaybeMessage< ::grpc::PointResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::PointResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ReportBugRequest* Arena::CreateMaybeMessage< ::grpc::ReportBugRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ReportBugRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginRequest* Arena::CreateMaybeMessage< ::grpc::LoginRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginAbortRequest* Arena::CreateMaybeMessage< ::grpc::LoginAbortRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginAbortRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ChangeLocalCacheRequest* Arena::CreateMaybeMessage< ::grpc::ChangeLocalCacheRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ChangeLocalCacheRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ChangePortsRequest* Arena::CreateMaybeMessage< ::grpc::ChangePortsRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ChangePortsRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::AvailableKeychainsResponse* Arena::CreateMaybeMessage< ::grpc::AvailableKeychainsResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::AvailableKeychainsResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::User* Arena::CreateMaybeMessage< ::grpc::User >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::User >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UserSplitModeRequest* Arena::CreateMaybeMessage< ::grpc::UserSplitModeRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UserSplitModeRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UserListResponse* Arena::CreateMaybeMessage< ::grpc::UserListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UserListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ConfigureAppleMailRequest* Arena::CreateMaybeMessage< ::grpc::ConfigureAppleMailRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ConfigureAppleMailRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::StreamEvent* Arena::CreateMaybeMessage< ::grpc::StreamEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::StreamEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::AppEvent* Arena::CreateMaybeMessage< ::grpc::AppEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::AppEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::InternetStatusEvent* Arena::CreateMaybeMessage< ::grpc::InternetStatusEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::InternetStatusEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::AutostartFinishedEvent* Arena::CreateMaybeMessage< ::grpc::AutostartFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::AutostartFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ResetFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ResetFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ResetFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ReportBugFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ReportBugFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ReportBugFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ReportBugSuccessEvent* Arena::CreateMaybeMessage< ::grpc::ReportBugSuccessEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ReportBugSuccessEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ReportBugErrorEvent* Arena::CreateMaybeMessage< ::grpc::ReportBugErrorEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ReportBugErrorEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ShowMainWindowEvent* Arena::CreateMaybeMessage< ::grpc::ShowMainWindowEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ShowMainWindowEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginEvent* Arena::CreateMaybeMessage< ::grpc::LoginEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginErrorEvent* Arena::CreateMaybeMessage< ::grpc::LoginErrorEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginErrorEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginTfaRequestedEvent* Arena::CreateMaybeMessage< ::grpc::LoginTfaRequestedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginTfaRequestedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginTwoPasswordsRequestedEvent* Arena::CreateMaybeMessage< ::grpc::LoginTwoPasswordsRequestedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginTwoPasswordsRequestedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::LoginFinishedEvent* Arena::CreateMaybeMessage< ::grpc::LoginFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::LoginFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateEvent* Arena::CreateMaybeMessage< ::grpc::UpdateEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateErrorEvent* Arena::CreateMaybeMessage< ::grpc::UpdateErrorEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateErrorEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateManualReadyEvent* Arena::CreateMaybeMessage< ::grpc::UpdateManualReadyEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateManualReadyEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateManualRestartNeededEvent* Arena::CreateMaybeMessage< ::grpc::UpdateManualRestartNeededEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateManualRestartNeededEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateForceEvent* Arena::CreateMaybeMessage< ::grpc::UpdateForceEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateForceEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateSilentRestartNeeded* Arena::CreateMaybeMessage< ::grpc::UpdateSilentRestartNeeded >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateSilentRestartNeeded >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateIsLatestVersion* Arena::CreateMaybeMessage< ::grpc::UpdateIsLatestVersion >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateIsLatestVersion >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UpdateCheckFinished* Arena::CreateMaybeMessage< ::grpc::UpdateCheckFinished >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UpdateCheckFinished >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::CacheEvent* Arena::CreateMaybeMessage< ::grpc::CacheEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::CacheEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::CacheErrorEvent* Arena::CreateMaybeMessage< ::grpc::CacheErrorEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::CacheErrorEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::CacheLocationChangeSuccessEvent* Arena::CreateMaybeMessage< ::grpc::CacheLocationChangeSuccessEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::CacheLocationChangeSuccessEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ChangeLocalCacheFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ChangeLocalCacheFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ChangeLocalCacheFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::MailSettingsEvent* Arena::CreateMaybeMessage< ::grpc::MailSettingsEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::MailSettingsEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::MailSettingsErrorEvent* Arena::CreateMaybeMessage< ::grpc::MailSettingsErrorEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::MailSettingsErrorEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UseSslForSmtpFinishedEvent* Arena::CreateMaybeMessage< ::grpc::UseSslForSmtpFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UseSslForSmtpFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ChangePortsFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ChangePortsFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ChangePortsFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::KeychainEvent* Arena::CreateMaybeMessage< ::grpc::KeychainEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::KeychainEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ChangeKeychainFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ChangeKeychainFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ChangeKeychainFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::HasNoKeychainEvent* Arena::CreateMaybeMessage< ::grpc::HasNoKeychainEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::HasNoKeychainEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::RebuildKeychainEvent* Arena::CreateMaybeMessage< ::grpc::RebuildKeychainEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::RebuildKeychainEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::MailEvent* Arena::CreateMaybeMessage< ::grpc::MailEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::MailEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::NoActiveKeyForRecipientEvent* Arena::CreateMaybeMessage< ::grpc::NoActiveKeyForRecipientEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::NoActiveKeyForRecipientEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::AddressChangedEvent* Arena::CreateMaybeMessage< ::grpc::AddressChangedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::AddressChangedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::AddressChangedLogoutEvent* Arena::CreateMaybeMessage< ::grpc::AddressChangedLogoutEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::AddressChangedLogoutEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ApiCertIssueEvent* Arena::CreateMaybeMessage< ::grpc::ApiCertIssueEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ApiCertIssueEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UserEvent* Arena::CreateMaybeMessage< ::grpc::UserEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UserEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::ToggleSplitModeFinishedEvent* Arena::CreateMaybeMessage< ::grpc::ToggleSplitModeFinishedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::ToggleSplitModeFinishedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UserDisconnectedEvent* Arena::CreateMaybeMessage< ::grpc::UserDisconnectedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UserDisconnectedEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::grpc::UserChangedEvent* Arena::CreateMaybeMessage< ::grpc::UserChangedEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::grpc::UserChangedEvent >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
