authentication_service.pb.h

Go to the documentation of this file.

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

#ifndef PROTOBUF_authentication_5fservice_2eproto__INCLUDED
#define PROTOBUF_authentication_5fservice_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
#include "account_types.pb.h"
#include "content_handle_types.pb.h"
#include "entity_types.pb.h"
#include "rpc_types.pb.h"
#include "ServiceBase.h"
#include "MessageBuffer.h"
#include <functional>
#include <type_traits>
// @@protoc_insertion_point(includes)

namespace bgs {
namespace protocol {
namespace authentication {
namespace v1 {

// Internal implementation detail -- do not call these.
void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
void protobuf_AssignDesc_authentication_5fservice_2eproto();
void protobuf_ShutdownFile_authentication_5fservice_2eproto();

class ModuleLoadRequest;
class ModuleNotification;
class ModuleMessageRequest;
class LogonRequest;
class LogonResult;
class GenerateSSOTokenRequest;
class GenerateSSOTokenResponse;
class LogonUpdateRequest;
class LogonQueueUpdateRequest;
class AccountSettingsNotification;
class ServerStateChangeRequest;
class VersionInfo;
class VersionInfoNotification;
class MemModuleLoadRequest;
class MemModuleLoadResponse;
class SelectGameAccountRequest;
class GameAccountSelectedRequest;
class GenerateWebCredentialsRequest;
class GenerateWebCredentialsResponse;
class VerifyWebCredentialsRequest;

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

class TC_SHARED_API ModuleLoadRequest : public ::google::protobuf::Message {
 public:
 ModuleLoadRequest();
 virtual ~ModuleLoadRequest();

 ModuleLoadRequest(const ModuleLoadRequest& from);

 inline ModuleLoadRequest& operator=(const ModuleLoadRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const ModuleLoadRequest& default_instance();

 void Swap(ModuleLoadRequest* other);

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

 ModuleLoadRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const ModuleLoadRequest& from);
 void MergeFrom(const ModuleLoadRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required .bgs.protocol.ContentHandle module_handle = 1;
 inline bool has_module_handle() const;
 inline void clear_module_handle();
 static const int kModuleHandleFieldNumber = 1;
 inline const ::bgs::protocol::ContentHandle& module_handle() const;
 inline ::bgs::protocol::ContentHandle* mutable_module_handle();
 inline ::bgs::protocol::ContentHandle* release_module_handle();
 inline void set_allocated_module_handle(::bgs::protocol::ContentHandle* module_handle);

 // optional bytes message = 2;
 inline bool has_message() const;
 inline void clear_message();
 static const int kMessageFieldNumber = 2;
 inline const ::std::string& message() const;
 inline void set_message(const ::std::string& value);
 inline void set_message(const char* value);
 inline void set_message(const void* value, size_t size);
 inline ::std::string* mutable_message();
 inline ::std::string* release_message();
 inline void set_allocated_message(::std::string* message);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleLoadRequest)
 private:
 inline void set_has_module_handle();
 inline void clear_has_module_handle();
 inline void set_has_message();
 inline void clear_has_message();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::bgs::protocol::ContentHandle* module_handle_;
 ::std::string* message_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static ModuleLoadRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API ModuleNotification : public ::google::protobuf::Message {
 public:
 ModuleNotification();
 virtual ~ModuleNotification();

 ModuleNotification(const ModuleNotification& from);

 inline ModuleNotification& operator=(const ModuleNotification& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const ModuleNotification& default_instance();

 void Swap(ModuleNotification* other);

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

 ModuleNotification* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const ModuleNotification& from);
 void MergeFrom(const ModuleNotification& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional int32 module_id = 2;
 inline bool has_module_id() const;
 inline void clear_module_id();
 static const int kModuleIdFieldNumber = 2;
 inline ::google::protobuf::int32 module_id() const;
 inline void set_module_id(::google::protobuf::int32 value);

 // optional uint32 result = 3;
 inline bool has_result() const;
 inline void clear_result();
 static const int kResultFieldNumber = 3;
 inline ::google::protobuf::uint32 result() const;
 inline void set_result(::google::protobuf::uint32 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleNotification)
 private:
 inline void set_has_module_id();
 inline void clear_has_module_id();
 inline void set_has_result();
 inline void clear_has_result();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::int32 module_id_;
 ::google::protobuf::uint32 result_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static ModuleNotification* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API ModuleMessageRequest : public ::google::protobuf::Message {
 public:
 ModuleMessageRequest();
 virtual ~ModuleMessageRequest();

 ModuleMessageRequest(const ModuleMessageRequest& from);

 inline ModuleMessageRequest& operator=(const ModuleMessageRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const ModuleMessageRequest& default_instance();

 void Swap(ModuleMessageRequest* other);

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

 ModuleMessageRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const ModuleMessageRequest& from);
 void MergeFrom(const ModuleMessageRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required int32 module_id = 1;
 inline bool has_module_id() const;
 inline void clear_module_id();
 static const int kModuleIdFieldNumber = 1;
 inline ::google::protobuf::int32 module_id() const;
 inline void set_module_id(::google::protobuf::int32 value);

 // optional bytes message = 2;
 inline bool has_message() const;
 inline void clear_message();
 static const int kMessageFieldNumber = 2;
 inline const ::std::string& message() const;
 inline void set_message(const ::std::string& value);
 inline void set_message(const char* value);
 inline void set_message(const void* value, size_t size);
 inline ::std::string* mutable_message();
 inline ::std::string* release_message();
 inline void set_allocated_message(::std::string* message);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ModuleMessageRequest)
 private:
 inline void set_has_module_id();
 inline void clear_has_module_id();
 inline void set_has_message();
 inline void clear_has_message();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::std::string* message_;
 ::google::protobuf::int32 module_id_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static ModuleMessageRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API LogonRequest : public ::google::protobuf::Message {
 public:
 LogonRequest();
 virtual ~LogonRequest();

 LogonRequest(const LogonRequest& from);

 inline LogonRequest& operator=(const LogonRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const LogonRequest& default_instance();

 void Swap(LogonRequest* other);

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

 LogonRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const LogonRequest& from);
 void MergeFrom(const LogonRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional string program = 1;
 inline bool has_program() const;
 inline void clear_program();
 static const int kProgramFieldNumber = 1;
 inline const ::std::string& program() const;
 inline void set_program(const ::std::string& value);
 inline void set_program(const char* value);
 inline void set_program(const char* value, size_t size);
 inline ::std::string* mutable_program();
 inline ::std::string* release_program();
 inline void set_allocated_program(::std::string* program);

 // optional string platform = 2;
 inline bool has_platform() const;
 inline void clear_platform();
 static const int kPlatformFieldNumber = 2;
 inline const ::std::string& platform() const;
 inline void set_platform(const ::std::string& value);
 inline void set_platform(const char* value);
 inline void set_platform(const char* value, size_t size);
 inline ::std::string* mutable_platform();
 inline ::std::string* release_platform();
 inline void set_allocated_platform(::std::string* platform);

 // optional string locale = 3;
 inline bool has_locale() const;
 inline void clear_locale();
 static const int kLocaleFieldNumber = 3;
 inline const ::std::string& locale() const;
 inline void set_locale(const ::std::string& value);
 inline void set_locale(const char* value);
 inline void set_locale(const char* value, size_t size);
 inline ::std::string* mutable_locale();
 inline ::std::string* release_locale();
 inline void set_allocated_locale(::std::string* locale);

 // optional string email = 4;
 inline bool has_email() const;
 inline void clear_email();
 static const int kEmailFieldNumber = 4;
 inline const ::std::string& email() const;
 inline void set_email(const ::std::string& value);
 inline void set_email(const char* value);
 inline void set_email(const char* value, size_t size);
 inline ::std::string* mutable_email();
 inline ::std::string* release_email();
 inline void set_allocated_email(::std::string* email);

 // optional string version = 5;
 inline bool has_version() const;
 inline void clear_version();
 static const int kVersionFieldNumber = 5;
 inline const ::std::string& version() const;
 inline void set_version(const ::std::string& value);
 inline void set_version(const char* value);
 inline void set_version(const char* value, size_t size);
 inline ::std::string* mutable_version();
 inline ::std::string* release_version();
 inline void set_allocated_version(::std::string* version);

 // optional int32 application_version = 6;
 inline bool has_application_version() const;
 inline void clear_application_version();
 static const int kApplicationVersionFieldNumber = 6;
 inline ::google::protobuf::int32 application_version() const;
 inline void set_application_version(::google::protobuf::int32 value);

 // optional bool public_computer = 7;
 inline bool has_public_computer() const;
 inline void clear_public_computer();
 static const int kPublicComputerFieldNumber = 7;
 inline bool public_computer() const;
 inline void set_public_computer(bool value);

 // optional bytes sso_id = 8;
 inline bool has_sso_id() const;
 inline void clear_sso_id();
 static const int kSsoIdFieldNumber = 8;
 inline const ::std::string& sso_id() const;
 inline void set_sso_id(const ::std::string& value);
 inline void set_sso_id(const char* value);
 inline void set_sso_id(const void* value, size_t size);
 inline ::std::string* mutable_sso_id();
 inline ::std::string* release_sso_id();
 inline void set_allocated_sso_id(::std::string* sso_id);

 // optional bool disconnect_on_cookie_fail = 9 [default = false];
 inline bool has_disconnect_on_cookie_fail() const;
 inline void clear_disconnect_on_cookie_fail();
 static const int kDisconnectOnCookieFailFieldNumber = 9;
 inline bool disconnect_on_cookie_fail() const;
 inline void set_disconnect_on_cookie_fail(bool value);

 // optional bool allow_logon_queue_notifications = 10 [default = false];
 inline bool has_allow_logon_queue_notifications() const;
 inline void clear_allow_logon_queue_notifications();
 static const int kAllowLogonQueueNotificationsFieldNumber = 10;
 inline bool allow_logon_queue_notifications() const;
 inline void set_allow_logon_queue_notifications(bool value);

 // optional bool web_client_verification = 11 [default = false];
 inline bool has_web_client_verification() const;
 inline void clear_web_client_verification();
 static const int kWebClientVerificationFieldNumber = 11;
 inline bool web_client_verification() const;
 inline void set_web_client_verification(bool value);

 // optional bytes cached_web_credentials = 12;
 inline bool has_cached_web_credentials() const;
 inline void clear_cached_web_credentials();
 static const int kCachedWebCredentialsFieldNumber = 12;
 inline const ::std::string& cached_web_credentials() const;
 inline void set_cached_web_credentials(const ::std::string& value);
 inline void set_cached_web_credentials(const char* value);
 inline void set_cached_web_credentials(const void* value, size_t size);
 inline ::std::string* mutable_cached_web_credentials();
 inline ::std::string* release_cached_web_credentials();
 inline void set_allocated_cached_web_credentials(::std::string* cached_web_credentials);

 // optional bool enable_cookie = 13 [default = true];
 inline bool has_enable_cookie() const;
 inline void clear_enable_cookie();
 static const int kEnableCookieFieldNumber = 13;
 inline bool enable_cookie() const;
 inline void set_enable_cookie(bool value);

 // optional string user_agent = 14;
 inline bool has_user_agent() const;
 inline void clear_user_agent();
 static const int kUserAgentFieldNumber = 14;
 inline const ::std::string& user_agent() const;
 inline void set_user_agent(const ::std::string& value);
 inline void set_user_agent(const char* value);
 inline void set_user_agent(const char* value, size_t size);
 inline ::std::string* mutable_user_agent();
 inline ::std::string* release_user_agent();
 inline void set_allocated_user_agent(::std::string* user_agent);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonRequest)
 private:
 inline void set_has_program();
 inline void clear_has_program();
 inline void set_has_platform();
 inline void clear_has_platform();
 inline void set_has_locale();
 inline void clear_has_locale();
 inline void set_has_email();
 inline void clear_has_email();
 inline void set_has_version();
 inline void clear_has_version();
 inline void set_has_application_version();
 inline void clear_has_application_version();
 inline void set_has_public_computer();
 inline void clear_has_public_computer();
 inline void set_has_sso_id();
 inline void clear_has_sso_id();
 inline void set_has_disconnect_on_cookie_fail();
 inline void clear_has_disconnect_on_cookie_fail();
 inline void set_has_allow_logon_queue_notifications();
 inline void clear_has_allow_logon_queue_notifications();
 inline void set_has_web_client_verification();
 inline void clear_has_web_client_verification();
 inline void set_has_cached_web_credentials();
 inline void clear_has_cached_web_credentials();
 inline void set_has_enable_cookie();
 inline void clear_has_enable_cookie();
 inline void set_has_user_agent();
 inline void clear_has_user_agent();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::std::string* program_;
 ::std::string* platform_;
 ::std::string* locale_;
 ::std::string* email_;
 ::std::string* version_;
 ::std::string* sso_id_;
 ::google::protobuf::int32 application_version_;
 bool public_computer_;
 bool disconnect_on_cookie_fail_;
 bool allow_logon_queue_notifications_;
 bool web_client_verification_;
 ::std::string* cached_web_credentials_;
 ::std::string* user_agent_;
 bool enable_cookie_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static LogonRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API LogonResult : public ::google::protobuf::Message {
 public:
 LogonResult();
 virtual ~LogonResult();

 LogonResult(const LogonResult& from);

 inline LogonResult& operator=(const LogonResult& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const LogonResult& default_instance();

 void Swap(LogonResult* other);

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

 LogonResult* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const LogonResult& from);
 void MergeFrom(const LogonResult& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required uint32 error_code = 1;
 inline bool has_error_code() const;
 inline void clear_error_code();
 static const int kErrorCodeFieldNumber = 1;
 inline ::google::protobuf::uint32 error_code() const;
 inline void set_error_code(::google::protobuf::uint32 value);

 // optional .bgs.protocol.EntityId account_id = 2;
 inline bool has_account_id() const;
 inline void clear_account_id();
 static const int kAccountIdFieldNumber = 2;
 inline const ::bgs::protocol::EntityId& account_id() const;
 inline ::bgs::protocol::EntityId* mutable_account_id();
 inline ::bgs::protocol::EntityId* release_account_id();
 inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);

 // repeated .bgs.protocol.EntityId game_account_id = 3;
 inline int game_account_id_size() const;
 inline void clear_game_account_id();
 static const int kGameAccountIdFieldNumber = 3;
 inline const ::bgs::protocol::EntityId& game_account_id(int index) const;
 inline ::bgs::protocol::EntityId* mutable_game_account_id(int index);
 inline ::bgs::protocol::EntityId* add_game_account_id();
 inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
 game_account_id() const;
 inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
 mutable_game_account_id();

 // optional string email = 4;
 inline bool has_email() const;
 inline void clear_email();
 static const int kEmailFieldNumber = 4;
 inline const ::std::string& email() const;
 inline void set_email(const ::std::string& value);
 inline void set_email(const char* value);
 inline void set_email(const char* value, size_t size);
 inline ::std::string* mutable_email();
 inline ::std::string* release_email();
 inline void set_allocated_email(::std::string* email);

 // repeated uint32 available_region = 5;
 inline int available_region_size() const;
 inline void clear_available_region();
 static const int kAvailableRegionFieldNumber = 5;
 inline ::google::protobuf::uint32 available_region(int index) const;
 inline void set_available_region(int index, ::google::protobuf::uint32 value);
 inline void add_available_region(::google::protobuf::uint32 value);
 inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
 available_region() const;
 inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
 mutable_available_region();

 // optional uint32 connected_region = 6;
 inline bool has_connected_region() const;
 inline void clear_connected_region();
 static const int kConnectedRegionFieldNumber = 6;
 inline ::google::protobuf::uint32 connected_region() const;
 inline void set_connected_region(::google::protobuf::uint32 value);

 // optional string battle_tag = 7;
 inline bool has_battle_tag() const;
 inline void clear_battle_tag();
 static const int kBattleTagFieldNumber = 7;
 inline const ::std::string& battle_tag() const;
 inline void set_battle_tag(const ::std::string& value);
 inline void set_battle_tag(const char* value);
 inline void set_battle_tag(const char* value, size_t size);
 inline ::std::string* mutable_battle_tag();
 inline ::std::string* release_battle_tag();
 inline void set_allocated_battle_tag(::std::string* battle_tag);

 // optional string geoip_country = 8;
 inline bool has_geoip_country() const;
 inline void clear_geoip_country();
 static const int kGeoipCountryFieldNumber = 8;
 inline const ::std::string& geoip_country() const;
 inline void set_geoip_country(const ::std::string& value);
 inline void set_geoip_country(const char* value);
 inline void set_geoip_country(const char* value, size_t size);
 inline ::std::string* mutable_geoip_country();
 inline ::std::string* release_geoip_country();
 inline void set_allocated_geoip_country(::std::string* geoip_country);

 // optional bytes session_key = 9;
 inline bool has_session_key() const;
 inline void clear_session_key();
 static const int kSessionKeyFieldNumber = 9;
 inline const ::std::string& session_key() const;
 inline void set_session_key(const ::std::string& value);
 inline void set_session_key(const char* value);
 inline void set_session_key(const void* value, size_t size);
 inline ::std::string* mutable_session_key();
 inline ::std::string* release_session_key();
 inline void set_allocated_session_key(::std::string* session_key);

 // optional bool restricted_mode = 10;
 inline bool has_restricted_mode() const;
 inline void clear_restricted_mode();
 static const int kRestrictedModeFieldNumber = 10;
 inline bool restricted_mode() const;
 inline void set_restricted_mode(bool value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonResult)
 private:
 inline void set_has_error_code();
 inline void clear_has_error_code();
 inline void set_has_account_id();
 inline void clear_has_account_id();
 inline void set_has_email();
 inline void clear_has_email();
 inline void set_has_connected_region();
 inline void clear_has_connected_region();
 inline void set_has_battle_tag();
 inline void clear_has_battle_tag();
 inline void set_has_geoip_country();
 inline void clear_has_geoip_country();
 inline void set_has_session_key();
 inline void clear_has_session_key();
 inline void set_has_restricted_mode();
 inline void clear_has_restricted_mode();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::bgs::protocol::EntityId* account_id_;
 ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > game_account_id_;
 ::google::protobuf::uint32 error_code_;
 ::google::protobuf::uint32 connected_region_;
 ::std::string* email_;
 ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > available_region_;
 ::std::string* battle_tag_;
 ::std::string* geoip_country_;
 ::std::string* session_key_;
 bool restricted_mode_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static LogonResult* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API GenerateSSOTokenRequest : public ::google::protobuf::Message {
 public:
 GenerateSSOTokenRequest();
 virtual ~GenerateSSOTokenRequest();

 GenerateSSOTokenRequest(const GenerateSSOTokenRequest& from);

 inline GenerateSSOTokenRequest& operator=(const GenerateSSOTokenRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const GenerateSSOTokenRequest& default_instance();

 void Swap(GenerateSSOTokenRequest* other);

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

 GenerateSSOTokenRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const GenerateSSOTokenRequest& from);
 void MergeFrom(const GenerateSSOTokenRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional fixed32 program = 1;
 inline bool has_program() const;
 inline void clear_program();
 static const int kProgramFieldNumber = 1;
 inline ::google::protobuf::uint32 program() const;
 inline void set_program(::google::protobuf::uint32 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
 private:
 inline void set_has_program();
 inline void clear_has_program();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::uint32 program_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static GenerateSSOTokenRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API GenerateSSOTokenResponse : public ::google::protobuf::Message {
 public:
 GenerateSSOTokenResponse();
 virtual ~GenerateSSOTokenResponse();

 GenerateSSOTokenResponse(const GenerateSSOTokenResponse& from);

 inline GenerateSSOTokenResponse& operator=(const GenerateSSOTokenResponse& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const GenerateSSOTokenResponse& default_instance();

 void Swap(GenerateSSOTokenResponse* other);

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

 GenerateSSOTokenResponse* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const GenerateSSOTokenResponse& from);
 void MergeFrom(const GenerateSSOTokenResponse& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional bytes sso_id = 1;
 inline bool has_sso_id() const;
 inline void clear_sso_id();
 static const int kSsoIdFieldNumber = 1;
 inline const ::std::string& sso_id() const;
 inline void set_sso_id(const ::std::string& value);
 inline void set_sso_id(const char* value);
 inline void set_sso_id(const void* value, size_t size);
 inline ::std::string* mutable_sso_id();
 inline ::std::string* release_sso_id();
 inline void set_allocated_sso_id(::std::string* sso_id);

 // optional bytes sso_secret = 2;
 inline bool has_sso_secret() const;
 inline void clear_sso_secret();
 static const int kSsoSecretFieldNumber = 2;
 inline const ::std::string& sso_secret() const;
 inline void set_sso_secret(const ::std::string& value);
 inline void set_sso_secret(const char* value);
 inline void set_sso_secret(const void* value, size_t size);
 inline ::std::string* mutable_sso_secret();
 inline ::std::string* release_sso_secret();
 inline void set_allocated_sso_secret(::std::string* sso_secret);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
 private:
 inline void set_has_sso_id();
 inline void clear_has_sso_id();
 inline void set_has_sso_secret();
 inline void clear_has_sso_secret();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::std::string* sso_id_;
 ::std::string* sso_secret_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static GenerateSSOTokenResponse* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API LogonUpdateRequest : public ::google::protobuf::Message {
 public:
 LogonUpdateRequest();
 virtual ~LogonUpdateRequest();

 LogonUpdateRequest(const LogonUpdateRequest& from);

 inline LogonUpdateRequest& operator=(const LogonUpdateRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const LogonUpdateRequest& default_instance();

 void Swap(LogonUpdateRequest* other);

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

 LogonUpdateRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const LogonUpdateRequest& from);
 void MergeFrom(const LogonUpdateRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required uint32 error_code = 1;
 inline bool has_error_code() const;
 inline void clear_error_code();
 static const int kErrorCodeFieldNumber = 1;
 inline ::google::protobuf::uint32 error_code() const;
 inline void set_error_code(::google::protobuf::uint32 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonUpdateRequest)
 private:
 inline void set_has_error_code();
 inline void clear_has_error_code();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::uint32 error_code_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static LogonUpdateRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API LogonQueueUpdateRequest : public ::google::protobuf::Message {
 public:
 LogonQueueUpdateRequest();
 virtual ~LogonQueueUpdateRequest();

 LogonQueueUpdateRequest(const LogonQueueUpdateRequest& from);

 inline LogonQueueUpdateRequest& operator=(const LogonQueueUpdateRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const LogonQueueUpdateRequest& default_instance();

 void Swap(LogonQueueUpdateRequest* other);

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

 LogonQueueUpdateRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const LogonQueueUpdateRequest& from);
 void MergeFrom(const LogonQueueUpdateRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required uint32 position = 1;
 inline bool has_position() const;
 inline void clear_position();
 static const int kPositionFieldNumber = 1;
 inline ::google::protobuf::uint32 position() const;
 inline void set_position(::google::protobuf::uint32 value);

 // required uint64 estimated_time = 2;
 inline bool has_estimated_time() const;
 inline void clear_estimated_time();
 static const int kEstimatedTimeFieldNumber = 2;
 inline ::google::protobuf::uint64 estimated_time() const;
 inline void set_estimated_time(::google::protobuf::uint64 value);

 // required uint64 eta_deviation_in_sec = 3;
 inline bool has_eta_deviation_in_sec() const;
 inline void clear_eta_deviation_in_sec();
 static const int kEtaDeviationInSecFieldNumber = 3;
 inline ::google::protobuf::uint64 eta_deviation_in_sec() const;
 inline void set_eta_deviation_in_sec(::google::protobuf::uint64 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
 private:
 inline void set_has_position();
 inline void clear_has_position();
 inline void set_has_estimated_time();
 inline void clear_has_estimated_time();
 inline void set_has_eta_deviation_in_sec();
 inline void clear_has_eta_deviation_in_sec();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::uint64 estimated_time_;
 ::google::protobuf::uint64 eta_deviation_in_sec_;
 ::google::protobuf::uint32 position_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static LogonQueueUpdateRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API AccountSettingsNotification : public ::google::protobuf::Message {
 public:
 AccountSettingsNotification();
 virtual ~AccountSettingsNotification();

 AccountSettingsNotification(const AccountSettingsNotification& from);

 inline AccountSettingsNotification& operator=(const AccountSettingsNotification& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const AccountSettingsNotification& default_instance();

 void Swap(AccountSettingsNotification* other);

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

 AccountSettingsNotification* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const AccountSettingsNotification& from);
 void MergeFrom(const AccountSettingsNotification& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
 inline int licenses_size() const;
 inline void clear_licenses();
 static const int kLicensesFieldNumber = 1;
 inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const;
 inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index);
 inline ::bgs::protocol::account::v1::AccountLicense* add_licenses();
 inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
 licenses() const;
 inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
 mutable_licenses();

 // optional bool is_using_rid = 2;
 inline bool has_is_using_rid() const;
 inline void clear_is_using_rid();
 static const int kIsUsingRidFieldNumber = 2;
 inline bool is_using_rid() const;
 inline void set_is_using_rid(bool value);

 // optional bool is_playing_from_igr = 3;
 inline bool has_is_playing_from_igr() const;
 inline void clear_is_playing_from_igr();
 static const int kIsPlayingFromIgrFieldNumber = 3;
 inline bool is_playing_from_igr() const;
 inline void set_is_playing_from_igr(bool value);

 // optional bool can_receive_voice = 4;
 inline bool has_can_receive_voice() const;
 inline void clear_can_receive_voice();
 static const int kCanReceiveVoiceFieldNumber = 4;
 inline bool can_receive_voice() const;
 inline void set_can_receive_voice(bool value);

 // optional bool can_send_voice = 5;
 inline bool has_can_send_voice() const;
 inline void clear_can_send_voice();
 static const int kCanSendVoiceFieldNumber = 5;
 inline bool can_send_voice() const;
 inline void set_can_send_voice(bool value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.AccountSettingsNotification)
 private:
 inline void set_has_is_using_rid();
 inline void clear_has_is_using_rid();
 inline void set_has_is_playing_from_igr();
 inline void clear_has_is_playing_from_igr();
 inline void set_has_can_receive_voice();
 inline void clear_has_can_receive_voice();
 inline void set_has_can_send_voice();
 inline void clear_has_can_send_voice();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
 bool is_using_rid_;
 bool is_playing_from_igr_;
 bool can_receive_voice_;
 bool can_send_voice_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static AccountSettingsNotification* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API ServerStateChangeRequest : public ::google::protobuf::Message {
 public:
 ServerStateChangeRequest();
 virtual ~ServerStateChangeRequest();

 ServerStateChangeRequest(const ServerStateChangeRequest& from);

 inline ServerStateChangeRequest& operator=(const ServerStateChangeRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const ServerStateChangeRequest& default_instance();

 void Swap(ServerStateChangeRequest* other);

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

 ServerStateChangeRequest* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const ServerStateChangeRequest& from);
 void MergeFrom(const ServerStateChangeRequest& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // required uint32 state = 1;
 inline bool has_state() const;
 inline void clear_state();
 static const int kStateFieldNumber = 1;
 inline ::google::protobuf::uint32 state() const;
 inline void set_state(::google::protobuf::uint32 value);

 // required uint64 event_time = 2;
 inline bool has_event_time() const;
 inline void clear_event_time();
 static const int kEventTimeFieldNumber = 2;
 inline ::google::protobuf::uint64 event_time() const;
 inline void set_event_time(::google::protobuf::uint64 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.ServerStateChangeRequest)
 private:
 inline void set_has_state();
 inline void clear_has_state();
 inline void set_has_event_time();
 inline void clear_has_event_time();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::uint64 event_time_;
 ::google::protobuf::uint32 state_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static ServerStateChangeRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API VersionInfo : public ::google::protobuf::Message {
 public:
 VersionInfo();
 virtual ~VersionInfo();

 VersionInfo(const VersionInfo& from);

 inline VersionInfo& operator=(const VersionInfo& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const VersionInfo& default_instance();

 void Swap(VersionInfo* other);

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

 VersionInfo* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const VersionInfo& from);
 void MergeFrom(const VersionInfo& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional uint32 number = 1;
 inline bool has_number() const;
 inline void clear_number();
 static const int kNumberFieldNumber = 1;
 inline ::google::protobuf::uint32 number() const;
 inline void set_number(::google::protobuf::uint32 value);

 // optional string patch = 2;
 inline bool has_patch() const;
 inline void clear_patch();
 static const int kPatchFieldNumber = 2;
 inline const ::std::string& patch() const;
 inline void set_patch(const ::std::string& value);
 inline void set_patch(const char* value);
 inline void set_patch(const char* value, size_t size);
 inline ::std::string* mutable_patch();
 inline ::std::string* release_patch();
 inline void set_allocated_patch(::std::string* patch);

 // optional bool is_optional = 3;
 inline bool has_is_optional() const;
 inline void clear_is_optional();
 static const int kIsOptionalFieldNumber = 3;
 inline bool is_optional() const;
 inline void set_is_optional(bool value);

 // optional uint64 kick_time = 4;
 inline bool has_kick_time() const;
 inline void clear_kick_time();
 static const int kKickTimeFieldNumber = 4;
 inline ::google::protobuf::uint64 kick_time() const;
 inline void set_kick_time(::google::protobuf::uint64 value);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VersionInfo)
 private:
 inline void set_has_number();
 inline void clear_has_number();
 inline void set_has_patch();
 inline void clear_has_patch();
 inline void set_has_is_optional();
 inline void clear_has_is_optional();
 inline void set_has_kick_time();
 inline void clear_has_kick_time();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::std::string* patch_;
 ::google::protobuf::uint32 number_;
 bool is_optional_;
 ::google::protobuf::uint64 kick_time_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static VersionInfo* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API VersionInfoNotification : public ::google::protobuf::Message {
 public:
 VersionInfoNotification();
 virtual ~VersionInfoNotification();

 VersionInfoNotification(const VersionInfoNotification& from);

 inline VersionInfoNotification& operator=(const VersionInfoNotification& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 return &_unknown_fields_;
 }

 static const ::google::protobuf::Descriptor* descriptor();
 static const VersionInfoNotification& default_instance();

 void Swap(VersionInfoNotification* other);

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

 VersionInfoNotification* New() const;
 void CopyFrom(const ::google::protobuf::Message& from);
 void MergeFrom(const ::google::protobuf::Message& from);
 void CopyFrom(const VersionInfoNotification& from);
 void MergeFrom(const VersionInfoNotification& from);
 void Clear();
 bool IsInitialized() const;

 int ByteSize() const;
 bool MergePartialFromCodedStream(
 ::google::protobuf::io::CodedInputStream* input);
 void SerializeWithCachedSizes(
 ::google::protobuf::io::CodedOutputStream* output) const;
 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 int GetCachedSize() const { return _cached_size_; }
 private:
 void SharedCtor();
 void SharedDtor();
 void SetCachedSize(int size) const;
 public:
 ::google::protobuf::Metadata GetMetadata() const;

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

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

 // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
 inline bool has_version_info() const;
 inline void clear_version_info();
 static const int kVersionInfoFieldNumber = 1;
 inline const ::bgs::protocol::authentication::v1::VersionInfo& version_info() const;
 inline ::bgs::protocol::authentication::v1::VersionInfo* mutable_version_info();
 inline ::bgs::protocol::authentication::v1::VersionInfo* release_version_info();
 inline void set_allocated_version_info(::bgs::protocol::authentication::v1::VersionInfo* version_info);

 // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VersionInfoNotification)
 private:
 inline void set_has_version_info();
 inline void clear_has_version_info();

 ::google::protobuf::UnknownFieldSet _unknown_fields_;

 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::bgs::protocol::authentication::v1::VersionInfo* version_info_;
 friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
 friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
 friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

 void InitAsDefaultInstance();
 static VersionInfoNotification* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API MemModuleLoadRequest : public ::google::protobuf::Message {
 public:
 MemModuleLoadRequest();
 virtual ~MemModuleLoadRequest();

 MemModuleLoadRequest(const MemModuleLoadRequest& from);

 inline MemModuleLoadRequest& operator=(const MemModuleLoadRequest& from) {
 CopyFrom(from);
 return *this;
 }

 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 return _unknown_fields_;
 }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MemModuleLoadRequest& default_instance();

  void Swap(MemModuleLoadRequest* other);

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

  MemModuleLoadRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MemModuleLoadRequest& from);
  void MergeFrom(const MemModuleLoadRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .bgs.protocol.ContentHandle handle = 1;
  inline bool has_handle() const;
  inline void clear_handle();
  static const int kHandleFieldNumber = 1;
  inline const ::bgs::protocol::ContentHandle& handle() const;
  inline ::bgs::protocol::ContentHandle* mutable_handle();
  inline ::bgs::protocol::ContentHandle* release_handle();
  inline void set_allocated_handle(::bgs::protocol::ContentHandle* handle);

  // required bytes key = 2;
  inline bool has_key() const;
  inline void clear_key();
  static const int kKeyFieldNumber = 2;
  inline const ::std::string& key() const;
  inline void set_key(const ::std::string& value);
  inline void set_key(const char* value);
  inline void set_key(const void* value, size_t size);
  inline ::std::string* mutable_key();
  inline ::std::string* release_key();
  inline void set_allocated_key(::std::string* key);

  // required bytes input = 3;
  inline bool has_input() const;
  inline void clear_input();
  static const int kInputFieldNumber = 3;
  inline const ::std::string& input() const;
  inline void set_input(const ::std::string& value);
  inline void set_input(const char* value);
  inline void set_input(const void* value, size_t size);
  inline ::std::string* mutable_input();
  inline ::std::string* release_input();
  inline void set_allocated_input(::std::string* input);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.MemModuleLoadRequest)
 private:
  inline void set_has_handle();
  inline void clear_has_handle();
  inline void set_has_key();
  inline void clear_has_key();
  inline void set_has_input();
  inline void clear_has_input();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::ContentHandle* handle_;
  ::std::string* key_;
  ::std::string* input_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static MemModuleLoadRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API MemModuleLoadResponse : public ::google::protobuf::Message {
 public:
  MemModuleLoadResponse();
  virtual ~MemModuleLoadResponse();

  MemModuleLoadResponse(const MemModuleLoadResponse& from);

  inline MemModuleLoadResponse& operator=(const MemModuleLoadResponse& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const MemModuleLoadResponse& default_instance();

  void Swap(MemModuleLoadResponse* other);

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

  MemModuleLoadResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MemModuleLoadResponse& from);
  void MergeFrom(const MemModuleLoadResponse& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required bytes data = 1;
  inline bool has_data() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data() const;
  inline void set_data(const ::std::string& value);
  inline void set_data(const char* value);
  inline void set_data(const void* value, size_t size);
  inline ::std::string* mutable_data();
  inline ::std::string* release_data();
  inline void set_allocated_data(::std::string* data);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.MemModuleLoadResponse)
 private:
  inline void set_has_data();
  inline void clear_has_data();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* data_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static MemModuleLoadResponse* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API SelectGameAccountRequest : public ::google::protobuf::Message {
 public:
  SelectGameAccountRequest();
  virtual ~SelectGameAccountRequest();

  SelectGameAccountRequest(const SelectGameAccountRequest& from);

  inline SelectGameAccountRequest& operator=(const SelectGameAccountRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SelectGameAccountRequest& default_instance();

  void Swap(SelectGameAccountRequest* other);

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

  SelectGameAccountRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SelectGameAccountRequest& from);
  void MergeFrom(const SelectGameAccountRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required .bgs.protocol.EntityId game_account_id = 1;
  inline bool has_game_account_id() const;
  inline void clear_game_account_id();
  static const int kGameAccountIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& game_account_id() const;
  inline ::bgs::protocol::EntityId* mutable_game_account_id();
  inline ::bgs::protocol::EntityId* release_game_account_id();
  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.SelectGameAccountRequest)
 private:
  inline void set_has_game_account_id();
  inline void clear_has_game_account_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* game_account_id_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static SelectGameAccountRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API GameAccountSelectedRequest : public ::google::protobuf::Message {
 public:
  GameAccountSelectedRequest();
  virtual ~GameAccountSelectedRequest();

  GameAccountSelectedRequest(const GameAccountSelectedRequest& from);

  inline GameAccountSelectedRequest& operator=(const GameAccountSelectedRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GameAccountSelectedRequest& default_instance();

  void Swap(GameAccountSelectedRequest* other);

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

  GameAccountSelectedRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GameAccountSelectedRequest& from);
  void MergeFrom(const GameAccountSelectedRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 result = 1;
  inline bool has_result() const;
  inline void clear_result();
  static const int kResultFieldNumber = 1;
  inline ::google::protobuf::uint32 result() const;
  inline void set_result(::google::protobuf::uint32 value);

  // optional .bgs.protocol.EntityId game_account_id = 2;
  inline bool has_game_account_id() const;
  inline void clear_game_account_id();
  static const int kGameAccountIdFieldNumber = 2;
  inline const ::bgs::protocol::EntityId& game_account_id() const;
  inline ::bgs::protocol::EntityId* mutable_game_account_id();
  inline ::bgs::protocol::EntityId* release_game_account_id();
  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
 private:
  inline void set_has_result();
  inline void clear_has_result();
  inline void set_has_game_account_id();
  inline void clear_has_game_account_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* game_account_id_;
  ::google::protobuf::uint32 result_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static GameAccountSelectedRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API GenerateWebCredentialsRequest : public ::google::protobuf::Message {
 public:
  GenerateWebCredentialsRequest();
  virtual ~GenerateWebCredentialsRequest();

  GenerateWebCredentialsRequest(const GenerateWebCredentialsRequest& from);

  inline GenerateWebCredentialsRequest& operator=(const GenerateWebCredentialsRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GenerateWebCredentialsRequest& default_instance();

  void Swap(GenerateWebCredentialsRequest* other);

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

  GenerateWebCredentialsRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GenerateWebCredentialsRequest& from);
  void MergeFrom(const GenerateWebCredentialsRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional fixed32 program = 1;
  inline bool has_program() const;
  inline void clear_program();
  static const int kProgramFieldNumber = 1;
  inline ::google::protobuf::uint32 program() const;
  inline void set_program(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
 private:
  inline void set_has_program();
  inline void clear_has_program();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 program_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static GenerateWebCredentialsRequest* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API GenerateWebCredentialsResponse : public ::google::protobuf::Message {
 public:
  GenerateWebCredentialsResponse();
  virtual ~GenerateWebCredentialsResponse();

  GenerateWebCredentialsResponse(const GenerateWebCredentialsResponse& from);

  inline GenerateWebCredentialsResponse& operator=(const GenerateWebCredentialsResponse& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const GenerateWebCredentialsResponse& default_instance();

  void Swap(GenerateWebCredentialsResponse* other);

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

  GenerateWebCredentialsResponse* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const GenerateWebCredentialsResponse& from);
  void MergeFrom(const GenerateWebCredentialsResponse& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional bytes web_credentials = 1;
  inline bool has_web_credentials() const;
  inline void clear_web_credentials();
  static const int kWebCredentialsFieldNumber = 1;
  inline const ::std::string& web_credentials() const;
  inline void set_web_credentials(const ::std::string& value);
  inline void set_web_credentials(const char* value);
  inline void set_web_credentials(const void* value, size_t size);
  inline ::std::string* mutable_web_credentials();
  inline ::std::string* release_web_credentials();
  inline void set_allocated_web_credentials(::std::string* web_credentials);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
 private:
  inline void set_has_web_credentials();
  inline void clear_has_web_credentials();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* web_credentials_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static GenerateWebCredentialsResponse* default_instance_;
};
// -------------------------------------------------------------------

class TC_SHARED_API VerifyWebCredentialsRequest : public ::google::protobuf::Message {
 public:
  VerifyWebCredentialsRequest();
  virtual ~VerifyWebCredentialsRequest();

  VerifyWebCredentialsRequest(const VerifyWebCredentialsRequest& from);

  inline VerifyWebCredentialsRequest& operator=(const VerifyWebCredentialsRequest& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const VerifyWebCredentialsRequest& default_instance();

  void Swap(VerifyWebCredentialsRequest* other);

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

  VerifyWebCredentialsRequest* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const VerifyWebCredentialsRequest& from);
  void MergeFrom(const VerifyWebCredentialsRequest& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional bytes web_credentials = 1;
  inline bool has_web_credentials() const;
  inline void clear_web_credentials();
  static const int kWebCredentialsFieldNumber = 1;
  inline const ::std::string& web_credentials() const;
  inline void set_web_credentials(const ::std::string& value);
  inline void set_web_credentials(const char* value);
  inline void set_web_credentials(const void* value, size_t size);
  inline ::std::string* mutable_web_credentials();
  inline ::std::string* release_web_credentials();
  inline void set_allocated_web_credentials(::std::string* web_credentials);

  // @@protoc_insertion_point(class_scope:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
 private:
  inline void set_has_web_credentials();
  inline void clear_has_web_credentials();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* web_credentials_;
  friend void TC_SHARED_API protobuf_AddDesc_authentication_5fservice_2eproto();
  friend void protobuf_AssignDesc_authentication_5fservice_2eproto();
  friend void protobuf_ShutdownFile_authentication_5fservice_2eproto();

  void InitAsDefaultInstance();
  static VerifyWebCredentialsRequest* default_instance_;
};
// ===================================================================

class TC_SHARED_API AuthenticationListener : public ServiceBase
{
 public:

  explicit AuthenticationListener(bool use_original_hash);
  virtual ~AuthenticationListener();

  typedef std::integral_constant<uint32, 0x71240E35u> OriginalHash;
  typedef std::integral_constant<uint32, 0x4DA86228u> NameHash;

  static google::protobuf::ServiceDescriptor const* descriptor();

  // client methods --------------------------------------------------

  void OnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request);
  void OnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void OnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request);
  void OnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request);
  void OnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, std::function<void(::bgs::protocol::authentication::v1::MemModuleLoadResponse const*)> responseCallback);
  void OnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request);
  void OnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request);
  void OnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request);
  void OnLogonQueueEnd(::bgs::protocol::NoData const* request);
  void OnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request);
  // server methods --------------------------------------------------

  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;

 protected:
  virtual uint32 HandleOnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request);
  virtual uint32 HandleOnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleOnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request);
  virtual uint32 HandleOnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request);
  virtual uint32 HandleOnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, ::bgs::protocol::authentication::v1::MemModuleLoadResponse* response);
  virtual uint32 HandleOnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request);
  virtual uint32 HandleOnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request);
  virtual uint32 HandleOnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request);
  virtual uint32 HandleOnLogonQueueEnd(::bgs::protocol::NoData const* request);
  virtual uint32 HandleOnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request);

 private:
  uint32 service_hash_;

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AuthenticationListener);
};

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

class TC_SHARED_API AuthenticationService : public ServiceBase
{
 public:

  explicit AuthenticationService(bool use_original_hash);
  virtual ~AuthenticationService();

  typedef std::integral_constant<uint32, 0xDECFC01u> OriginalHash;
  typedef std::integral_constant<uint32, 0xFF5A6AC3u> NameHash;

  static google::protobuf::ServiceDescriptor const* descriptor();

  // client methods --------------------------------------------------

  void Logon(::bgs::protocol::authentication::v1::LogonRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void ModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void ModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void SelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void GenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, std::function<void(::bgs::protocol::authentication::v1::GenerateSSOTokenResponse const*)> responseCallback);
  void SelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void VerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
  void GenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, std::function<void(::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse const*)> responseCallback);
  // server methods --------------------------------------------------

  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;

 protected:
  virtual uint32 HandleLogon(::bgs::protocol::authentication::v1::LogonRequest const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleSelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleGenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse* response);
  virtual uint32 HandleSelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleVerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, ::bgs::protocol::NoData* response);
  virtual uint32 HandleGenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse* response);

 private:
  uint32 service_hash_;

  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AuthenticationService);
};

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


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

// ModuleLoadRequest

// required .bgs.protocol.ContentHandle module_handle = 1;
inline bool ModuleLoadRequest::has_module_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ModuleLoadRequest::set_has_module_handle() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ModuleLoadRequest::clear_has_module_handle() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ModuleLoadRequest::clear_module_handle() {
  if (module_handle_ != NULL) module_handle_->::bgs::protocol::ContentHandle::Clear();
  clear_has_module_handle();
}
inline const ::bgs::protocol::ContentHandle& ModuleLoadRequest::module_handle() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle)
  return module_handle_ != NULL ? *module_handle_ : *default_instance_->module_handle_;
}
inline ::bgs::protocol::ContentHandle* ModuleLoadRequest::mutable_module_handle() {
  set_has_module_handle();
  if (module_handle_ == NULL) module_handle_ = new ::bgs::protocol::ContentHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle)
  return module_handle_;
}
inline ::bgs::protocol::ContentHandle* ModuleLoadRequest::release_module_handle() {
  clear_has_module_handle();
  ::bgs::protocol::ContentHandle* temp = module_handle_;
  module_handle_ = NULL;
  return temp;
}
inline void ModuleLoadRequest::set_allocated_module_handle(::bgs::protocol::ContentHandle* module_handle) {
  delete module_handle_;
  module_handle_ = module_handle;
  if (module_handle) {
    set_has_module_handle();
  } else {
    clear_has_module_handle();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleLoadRequest.module_handle)
}

// optional bytes message = 2;
inline bool ModuleLoadRequest::has_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ModuleLoadRequest::set_has_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ModuleLoadRequest::clear_has_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ModuleLoadRequest::clear_message() {
  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_->clear();
  }
  clear_has_message();
}
inline const ::std::string& ModuleLoadRequest::message() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
  return *message_;
}
inline void ModuleLoadRequest::set_message(const ::std::string& value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
}
inline void ModuleLoadRequest::set_message(const char* value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
}
inline void ModuleLoadRequest::set_message(const void* value, size_t size) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
}
inline ::std::string* ModuleLoadRequest::mutable_message() {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
  return message_;
}
inline ::std::string* ModuleLoadRequest::release_message() {
  clear_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = message_;
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ModuleLoadRequest::set_allocated_message(::std::string* message) {
  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete message_;
  }
  if (message) {
    set_has_message();
    message_ = message;
  } else {
    clear_has_message();
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleLoadRequest.message)
}

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

// ModuleNotification

// optional int32 module_id = 2;
inline bool ModuleNotification::has_module_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ModuleNotification::set_has_module_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ModuleNotification::clear_has_module_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ModuleNotification::clear_module_id() {
  module_id_ = 0;
  clear_has_module_id();
}
inline ::google::protobuf::int32 ModuleNotification::module_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleNotification.module_id)
  return module_id_;
}
inline void ModuleNotification::set_module_id(::google::protobuf::int32 value) {
  set_has_module_id();
  module_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleNotification.module_id)
}

// optional uint32 result = 3;
inline bool ModuleNotification::has_result() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ModuleNotification::set_has_result() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ModuleNotification::clear_has_result() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ModuleNotification::clear_result() {
  result_ = 0u;
  clear_has_result();
}
inline ::google::protobuf::uint32 ModuleNotification::result() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleNotification.result)
  return result_;
}
inline void ModuleNotification::set_result(::google::protobuf::uint32 value) {
  set_has_result();
  result_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleNotification.result)
}

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

// ModuleMessageRequest

// required int32 module_id = 1;
inline bool ModuleMessageRequest::has_module_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ModuleMessageRequest::set_has_module_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ModuleMessageRequest::clear_has_module_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ModuleMessageRequest::clear_module_id() {
  module_id_ = 0;
  clear_has_module_id();
}
inline ::google::protobuf::int32 ModuleMessageRequest::module_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleMessageRequest.module_id)
  return module_id_;
}
inline void ModuleMessageRequest::set_module_id(::google::protobuf::int32 value) {
  set_has_module_id();
  module_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleMessageRequest.module_id)
}

// optional bytes message = 2;
inline bool ModuleMessageRequest::has_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ModuleMessageRequest::set_has_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ModuleMessageRequest::clear_has_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ModuleMessageRequest::clear_message() {
  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_->clear();
  }
  clear_has_message();
}
inline const ::std::string& ModuleMessageRequest::message() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
  return *message_;
}
inline void ModuleMessageRequest::set_message(const ::std::string& value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
}
inline void ModuleMessageRequest::set_message(const char* value) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
}
inline void ModuleMessageRequest::set_message(const void* value, size_t size) {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  message_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
}
inline ::std::string* ModuleMessageRequest::mutable_message() {
  set_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    message_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
  return message_;
}
inline ::std::string* ModuleMessageRequest::release_message() {
  clear_has_message();
  if (message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = message_;
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ModuleMessageRequest::set_allocated_message(::std::string* message) {
  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete message_;
  }
  if (message) {
    set_has_message();
    message_ = message;
  } else {
    clear_has_message();
    message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.ModuleMessageRequest.message)
}

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

// LogonRequest

// optional string program = 1;
inline bool LogonRequest::has_program() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogonRequest::set_has_program() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LogonRequest::clear_has_program() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LogonRequest::clear_program() {
  if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_->clear();
  }
  clear_has_program();
}
inline const ::std::string& LogonRequest::program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.program)
  return *program_;
}
inline void LogonRequest::set_program(const ::std::string& value) {
  set_has_program();
  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_ = new ::std::string;
  }
  program_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.program)
}
inline void LogonRequest::set_program(const char* value) {
  set_has_program();
  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_ = new ::std::string;
  }
  program_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.program)
}
inline void LogonRequest::set_program(const char* value, size_t size) {
  set_has_program();
  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_ = new ::std::string;
  }
  program_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.program)
}
inline ::std::string* LogonRequest::mutable_program() {
  set_has_program();
  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.program)
  return program_;
}
inline ::std::string* LogonRequest::release_program() {
  clear_has_program();
  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = program_;
    program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_program(::std::string* program) {
  if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete program_;
  }
  if (program) {
    set_has_program();
    program_ = program;
  } else {
    clear_has_program();
    program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.program)
}

// optional string platform = 2;
inline bool LogonRequest::has_platform() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LogonRequest::set_has_platform() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LogonRequest::clear_has_platform() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LogonRequest::clear_platform() {
  if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    platform_->clear();
  }
  clear_has_platform();
}
inline const ::std::string& LogonRequest::platform() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.platform)
  return *platform_;
}
inline void LogonRequest::set_platform(const ::std::string& value) {
  set_has_platform();
  if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    platform_ = new ::std::string;
  }
  platform_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.platform)
}
inline void LogonRequest::set_platform(const char* value) {
  set_has_platform();
  if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    platform_ = new ::std::string;
  }
  platform_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.platform)
}
inline void LogonRequest::set_platform(const char* value, size_t size) {
  set_has_platform();
  if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    platform_ = new ::std::string;
  }
  platform_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.platform)
}
inline ::std::string* LogonRequest::mutable_platform() {
  set_has_platform();
  if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    platform_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.platform)
  return platform_;
}
inline ::std::string* LogonRequest::release_platform() {
  clear_has_platform();
  if (platform_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = platform_;
    platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_platform(::std::string* platform) {
  if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete platform_;
  }
  if (platform) {
    set_has_platform();
    platform_ = platform;
  } else {
    clear_has_platform();
    platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.platform)
}

// optional string locale = 3;
inline bool LogonRequest::has_locale() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LogonRequest::set_has_locale() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LogonRequest::clear_has_locale() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LogonRequest::clear_locale() {
  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    locale_->clear();
  }
  clear_has_locale();
}
inline const ::std::string& LogonRequest::locale() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.locale)
  return *locale_;
}
inline void LogonRequest::set_locale(const ::std::string& value) {
  set_has_locale();
  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    locale_ = new ::std::string;
  }
  locale_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.locale)
}
inline void LogonRequest::set_locale(const char* value) {
  set_has_locale();
  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    locale_ = new ::std::string;
  }
  locale_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.locale)
}
inline void LogonRequest::set_locale(const char* value, size_t size) {
  set_has_locale();
  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    locale_ = new ::std::string;
  }
  locale_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.locale)
}
inline ::std::string* LogonRequest::mutable_locale() {
  set_has_locale();
  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    locale_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.locale)
  return locale_;
}
inline ::std::string* LogonRequest::release_locale() {
  clear_has_locale();
  if (locale_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = locale_;
    locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_locale(::std::string* locale) {
  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete locale_;
  }
  if (locale) {
    set_has_locale();
    locale_ = locale;
  } else {
    clear_has_locale();
    locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.locale)
}

// optional string email = 4;
inline bool LogonRequest::has_email() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LogonRequest::set_has_email() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LogonRequest::clear_has_email() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LogonRequest::clear_email() {
  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_->clear();
  }
  clear_has_email();
}
inline const ::std::string& LogonRequest::email() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.email)
  return *email_;
}
inline void LogonRequest::set_email(const ::std::string& value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.email)
}
inline void LogonRequest::set_email(const char* value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.email)
}
inline void LogonRequest::set_email(const char* value, size_t size) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.email)
}
inline ::std::string* LogonRequest::mutable_email() {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.email)
  return email_;
}
inline ::std::string* LogonRequest::release_email() {
  clear_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = email_;
    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_email(::std::string* email) {
  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete email_;
  }
  if (email) {
    set_has_email();
    email_ = email;
  } else {
    clear_has_email();
    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.email)
}

// optional string version = 5;
inline bool LogonRequest::has_version() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void LogonRequest::set_has_version() {
  _has_bits_[0] |= 0x00000010u;
}
inline void LogonRequest::clear_has_version() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void LogonRequest::clear_version() {
  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    version_->clear();
  }
  clear_has_version();
}
inline const ::std::string& LogonRequest::version() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.version)
  return *version_;
}
inline void LogonRequest::set_version(const ::std::string& value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    version_ = new ::std::string;
  }
  version_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.version)
}
inline void LogonRequest::set_version(const char* value) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    version_ = new ::std::string;
  }
  version_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.version)
}
inline void LogonRequest::set_version(const char* value, size_t size) {
  set_has_version();
  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    version_ = new ::std::string;
  }
  version_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.version)
}
inline ::std::string* LogonRequest::mutable_version() {
  set_has_version();
  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    version_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.version)
  return version_;
}
inline ::std::string* LogonRequest::release_version() {
  clear_has_version();
  if (version_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = version_;
    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_version(::std::string* version) {
  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete version_;
  }
  if (version) {
    set_has_version();
    version_ = version;
  } else {
    clear_has_version();
    version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.version)
}

// optional int32 application_version = 6;
inline bool LogonRequest::has_application_version() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LogonRequest::set_has_application_version() {
  _has_bits_[0] |= 0x00000020u;
}
inline void LogonRequest::clear_has_application_version() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void LogonRequest::clear_application_version() {
  application_version_ = 0;
  clear_has_application_version();
}
inline ::google::protobuf::int32 LogonRequest::application_version() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.application_version)
  return application_version_;
}
inline void LogonRequest::set_application_version(::google::protobuf::int32 value) {
  set_has_application_version();
  application_version_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.application_version)
}

// optional bool public_computer = 7;
inline bool LogonRequest::has_public_computer() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void LogonRequest::set_has_public_computer() {
  _has_bits_[0] |= 0x00000040u;
}
inline void LogonRequest::clear_has_public_computer() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void LogonRequest::clear_public_computer() {
  public_computer_ = false;
  clear_has_public_computer();
}
inline bool LogonRequest::public_computer() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.public_computer)
  return public_computer_;
}
inline void LogonRequest::set_public_computer(bool value) {
  set_has_public_computer();
  public_computer_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.public_computer)
}

// optional bytes sso_id = 8;
inline bool LogonRequest::has_sso_id() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void LogonRequest::set_has_sso_id() {
  _has_bits_[0] |= 0x00000080u;
}
inline void LogonRequest::clear_has_sso_id() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void LogonRequest::clear_sso_id() {
  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_->clear();
  }
  clear_has_sso_id();
}
inline const ::std::string& LogonRequest::sso_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.sso_id)
  return *sso_id_;
}
inline void LogonRequest::set_sso_id(const ::std::string& value) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.sso_id)
}
inline void LogonRequest::set_sso_id(const char* value) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.sso_id)
}
inline void LogonRequest::set_sso_id(const void* value, size_t size) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.sso_id)
}
inline ::std::string* LogonRequest::mutable_sso_id() {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.sso_id)
  return sso_id_;
}
inline ::std::string* LogonRequest::release_sso_id() {
  clear_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = sso_id_;
    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_sso_id(::std::string* sso_id) {
  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete sso_id_;
  }
  if (sso_id) {
    set_has_sso_id();
    sso_id_ = sso_id;
  } else {
    clear_has_sso_id();
    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.sso_id)
}

// optional bool disconnect_on_cookie_fail = 9 [default = false];
inline bool LogonRequest::has_disconnect_on_cookie_fail() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void LogonRequest::set_has_disconnect_on_cookie_fail() {
  _has_bits_[0] |= 0x00000100u;
}
inline void LogonRequest::clear_has_disconnect_on_cookie_fail() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void LogonRequest::clear_disconnect_on_cookie_fail() {
  disconnect_on_cookie_fail_ = false;
  clear_has_disconnect_on_cookie_fail();
}
inline bool LogonRequest::disconnect_on_cookie_fail() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail)
  return disconnect_on_cookie_fail_;
}
inline void LogonRequest::set_disconnect_on_cookie_fail(bool value) {
  set_has_disconnect_on_cookie_fail();
  disconnect_on_cookie_fail_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.disconnect_on_cookie_fail)
}

// optional bool allow_logon_queue_notifications = 10 [default = false];
inline bool LogonRequest::has_allow_logon_queue_notifications() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void LogonRequest::set_has_allow_logon_queue_notifications() {
  _has_bits_[0] |= 0x00000200u;
}
inline void LogonRequest::clear_has_allow_logon_queue_notifications() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void LogonRequest::clear_allow_logon_queue_notifications() {
  allow_logon_queue_notifications_ = false;
  clear_has_allow_logon_queue_notifications();
}
inline bool LogonRequest::allow_logon_queue_notifications() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.allow_logon_queue_notifications)
  return allow_logon_queue_notifications_;
}
inline void LogonRequest::set_allow_logon_queue_notifications(bool value) {
  set_has_allow_logon_queue_notifications();
  allow_logon_queue_notifications_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.allow_logon_queue_notifications)
}

// optional bool web_client_verification = 11 [default = false];
inline bool LogonRequest::has_web_client_verification() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void LogonRequest::set_has_web_client_verification() {
  _has_bits_[0] |= 0x00000400u;
}
inline void LogonRequest::clear_has_web_client_verification() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void LogonRequest::clear_web_client_verification() {
  web_client_verification_ = false;
  clear_has_web_client_verification();
}
inline bool LogonRequest::web_client_verification() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.web_client_verification)
  return web_client_verification_;
}
inline void LogonRequest::set_web_client_verification(bool value) {
  set_has_web_client_verification();
  web_client_verification_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.web_client_verification)
}

// optional bytes cached_web_credentials = 12;
inline bool LogonRequest::has_cached_web_credentials() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void LogonRequest::set_has_cached_web_credentials() {
  _has_bits_[0] |= 0x00000800u;
}
inline void LogonRequest::clear_has_cached_web_credentials() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void LogonRequest::clear_cached_web_credentials() {
  if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    cached_web_credentials_->clear();
  }
  clear_has_cached_web_credentials();
}
inline const ::std::string& LogonRequest::cached_web_credentials() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
  return *cached_web_credentials_;
}
inline void LogonRequest::set_cached_web_credentials(const ::std::string& value) {
  set_has_cached_web_credentials();
  if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    cached_web_credentials_ = new ::std::string;
  }
  cached_web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
}
inline void LogonRequest::set_cached_web_credentials(const char* value) {
  set_has_cached_web_credentials();
  if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    cached_web_credentials_ = new ::std::string;
  }
  cached_web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
}
inline void LogonRequest::set_cached_web_credentials(const void* value, size_t size) {
  set_has_cached_web_credentials();
  if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    cached_web_credentials_ = new ::std::string;
  }
  cached_web_credentials_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
}
inline ::std::string* LogonRequest::mutable_cached_web_credentials() {
  set_has_cached_web_credentials();
  if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    cached_web_credentials_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
  return cached_web_credentials_;
}
inline ::std::string* LogonRequest::release_cached_web_credentials() {
  clear_has_cached_web_credentials();
  if (cached_web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = cached_web_credentials_;
    cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_cached_web_credentials(::std::string* cached_web_credentials) {
  if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete cached_web_credentials_;
  }
  if (cached_web_credentials) {
    set_has_cached_web_credentials();
    cached_web_credentials_ = cached_web_credentials;
  } else {
    clear_has_cached_web_credentials();
    cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.cached_web_credentials)
}

// optional bool enable_cookie = 13 [default = true];
inline bool LogonRequest::has_enable_cookie() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void LogonRequest::set_has_enable_cookie() {
  _has_bits_[0] |= 0x00001000u;
}
inline void LogonRequest::clear_has_enable_cookie() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void LogonRequest::clear_enable_cookie() {
  enable_cookie_ = true;
  clear_has_enable_cookie();
}
inline bool LogonRequest::enable_cookie() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.enable_cookie)
  return enable_cookie_;
}
inline void LogonRequest::set_enable_cookie(bool value) {
  set_has_enable_cookie();
  enable_cookie_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.enable_cookie)
}

// optional string user_agent = 14;
inline bool LogonRequest::has_user_agent() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void LogonRequest::set_has_user_agent() {
  _has_bits_[0] |= 0x00002000u;
}
inline void LogonRequest::clear_has_user_agent() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void LogonRequest::clear_user_agent() {
  if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_agent_->clear();
  }
  clear_has_user_agent();
}
inline const ::std::string& LogonRequest::user_agent() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonRequest.user_agent)
  return *user_agent_;
}
inline void LogonRequest::set_user_agent(const ::std::string& value) {
  set_has_user_agent();
  if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_agent_ = new ::std::string;
  }
  user_agent_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonRequest.user_agent)
}
inline void LogonRequest::set_user_agent(const char* value) {
  set_has_user_agent();
  if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_agent_ = new ::std::string;
  }
  user_agent_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonRequest.user_agent)
}
inline void LogonRequest::set_user_agent(const char* value, size_t size) {
  set_has_user_agent();
  if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_agent_ = new ::std::string;
  }
  user_agent_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonRequest.user_agent)
}
inline ::std::string* LogonRequest::mutable_user_agent() {
  set_has_user_agent();
  if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_agent_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonRequest.user_agent)
  return user_agent_;
}
inline ::std::string* LogonRequest::release_user_agent() {
  clear_has_user_agent();
  if (user_agent_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = user_agent_;
    user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonRequest::set_allocated_user_agent(::std::string* user_agent) {
  if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete user_agent_;
  }
  if (user_agent) {
    set_has_user_agent();
    user_agent_ = user_agent;
  } else {
    clear_has_user_agent();
    user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonRequest.user_agent)
}

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

// LogonResult

// required uint32 error_code = 1;
inline bool LogonResult::has_error_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogonResult::set_has_error_code() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LogonResult::clear_has_error_code() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LogonResult::clear_error_code() {
  error_code_ = 0u;
  clear_has_error_code();
}
inline ::google::protobuf::uint32 LogonResult::error_code() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.error_code)
  return error_code_;
}
inline void LogonResult::set_error_code(::google::protobuf::uint32 value) {
  set_has_error_code();
  error_code_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.error_code)
}

// optional .bgs.protocol.EntityId account_id = 2;
inline bool LogonResult::has_account_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LogonResult::set_has_account_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LogonResult::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LogonResult::clear_account_id() {
  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_account_id();
}
inline const ::bgs::protocol::EntityId& LogonResult::account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.account_id)
  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
}
inline ::bgs::protocol::EntityId* LogonResult::mutable_account_id() {
  set_has_account_id();
  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.account_id)
  return account_id_;
}
inline ::bgs::protocol::EntityId* LogonResult::release_account_id() {
  clear_has_account_id();
  ::bgs::protocol::EntityId* temp = account_id_;
  account_id_ = NULL;
  return temp;
}
inline void LogonResult::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
  delete account_id_;
  account_id_ = account_id;
  if (account_id) {
    set_has_account_id();
  } else {
    clear_has_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.account_id)
}

// repeated .bgs.protocol.EntityId game_account_id = 3;
inline int LogonResult::game_account_id_size() const {
  return game_account_id_.size();
}
inline void LogonResult::clear_game_account_id() {
  game_account_id_.Clear();
}
inline const ::bgs::protocol::EntityId& LogonResult::game_account_id(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.game_account_id)
  return game_account_id_.Get(index);
}
inline ::bgs::protocol::EntityId* LogonResult::mutable_game_account_id(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.game_account_id)
  return game_account_id_.Mutable(index);
}
inline ::bgs::protocol::EntityId* LogonResult::add_game_account_id() {
  // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.LogonResult.game_account_id)
  return game_account_id_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
LogonResult::game_account_id() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.LogonResult.game_account_id)
  return game_account_id_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
LogonResult::mutable_game_account_id() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.LogonResult.game_account_id)
  return &game_account_id_;
}

// optional string email = 4;
inline bool LogonResult::has_email() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void LogonResult::set_has_email() {
  _has_bits_[0] |= 0x00000008u;
}
inline void LogonResult::clear_has_email() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void LogonResult::clear_email() {
  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_->clear();
  }
  clear_has_email();
}
inline const ::std::string& LogonResult::email() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.email)
  return *email_;
}
inline void LogonResult::set_email(const ::std::string& value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.email)
}
inline void LogonResult::set_email(const char* value) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.email)
}
inline void LogonResult::set_email(const char* value, size_t size) {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  email_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.email)
}
inline ::std::string* LogonResult::mutable_email() {
  set_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    email_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.email)
  return email_;
}
inline ::std::string* LogonResult::release_email() {
  clear_has_email();
  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = email_;
    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonResult::set_allocated_email(::std::string* email) {
  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete email_;
  }
  if (email) {
    set_has_email();
    email_ = email;
  } else {
    clear_has_email();
    email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.email)
}

// repeated uint32 available_region = 5;
inline int LogonResult::available_region_size() const {
  return available_region_.size();
}
inline void LogonResult::clear_available_region() {
  available_region_.Clear();
}
inline ::google::protobuf::uint32 LogonResult::available_region(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.available_region)
  return available_region_.Get(index);
}
inline void LogonResult::set_available_region(int index, ::google::protobuf::uint32 value) {
  available_region_.Set(index, value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.available_region)
}
inline void LogonResult::add_available_region(::google::protobuf::uint32 value) {
  available_region_.Add(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.LogonResult.available_region)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
LogonResult::available_region() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.LogonResult.available_region)
  return available_region_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
LogonResult::mutable_available_region() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.LogonResult.available_region)
  return &available_region_;
}

// optional uint32 connected_region = 6;
inline bool LogonResult::has_connected_region() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void LogonResult::set_has_connected_region() {
  _has_bits_[0] |= 0x00000020u;
}
inline void LogonResult::clear_has_connected_region() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void LogonResult::clear_connected_region() {
  connected_region_ = 0u;
  clear_has_connected_region();
}
inline ::google::protobuf::uint32 LogonResult::connected_region() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.connected_region)
  return connected_region_;
}
inline void LogonResult::set_connected_region(::google::protobuf::uint32 value) {
  set_has_connected_region();
  connected_region_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.connected_region)
}

// optional string battle_tag = 7;
inline bool LogonResult::has_battle_tag() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void LogonResult::set_has_battle_tag() {
  _has_bits_[0] |= 0x00000040u;
}
inline void LogonResult::clear_has_battle_tag() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void LogonResult::clear_battle_tag() {
  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_->clear();
  }
  clear_has_battle_tag();
}
inline const ::std::string& LogonResult::battle_tag() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.battle_tag)
  return *battle_tag_;
}
inline void LogonResult::set_battle_tag(const ::std::string& value) {
  set_has_battle_tag();
  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_ = new ::std::string;
  }
  battle_tag_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.battle_tag)
}
inline void LogonResult::set_battle_tag(const char* value) {
  set_has_battle_tag();
  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_ = new ::std::string;
  }
  battle_tag_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.battle_tag)
}
inline void LogonResult::set_battle_tag(const char* value, size_t size) {
  set_has_battle_tag();
  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_ = new ::std::string;
  }
  battle_tag_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.battle_tag)
}
inline ::std::string* LogonResult::mutable_battle_tag() {
  set_has_battle_tag();
  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.battle_tag)
  return battle_tag_;
}
inline ::std::string* LogonResult::release_battle_tag() {
  clear_has_battle_tag();
  if (battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = battle_tag_;
    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonResult::set_allocated_battle_tag(::std::string* battle_tag) {
  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete battle_tag_;
  }
  if (battle_tag) {
    set_has_battle_tag();
    battle_tag_ = battle_tag;
  } else {
    clear_has_battle_tag();
    battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.battle_tag)
}

// optional string geoip_country = 8;
inline bool LogonResult::has_geoip_country() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void LogonResult::set_has_geoip_country() {
  _has_bits_[0] |= 0x00000080u;
}
inline void LogonResult::clear_has_geoip_country() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void LogonResult::clear_geoip_country() {
  if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    geoip_country_->clear();
  }
  clear_has_geoip_country();
}
inline const ::std::string& LogonResult::geoip_country() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.geoip_country)
  return *geoip_country_;
}
inline void LogonResult::set_geoip_country(const ::std::string& value) {
  set_has_geoip_country();
  if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    geoip_country_ = new ::std::string;
  }
  geoip_country_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.geoip_country)
}
inline void LogonResult::set_geoip_country(const char* value) {
  set_has_geoip_country();
  if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    geoip_country_ = new ::std::string;
  }
  geoip_country_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.geoip_country)
}
inline void LogonResult::set_geoip_country(const char* value, size_t size) {
  set_has_geoip_country();
  if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    geoip_country_ = new ::std::string;
  }
  geoip_country_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.geoip_country)
}
inline ::std::string* LogonResult::mutable_geoip_country() {
  set_has_geoip_country();
  if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    geoip_country_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.geoip_country)
  return geoip_country_;
}
inline ::std::string* LogonResult::release_geoip_country() {
  clear_has_geoip_country();
  if (geoip_country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = geoip_country_;
    geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonResult::set_allocated_geoip_country(::std::string* geoip_country) {
  if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete geoip_country_;
  }
  if (geoip_country) {
    set_has_geoip_country();
    geoip_country_ = geoip_country;
  } else {
    clear_has_geoip_country();
    geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.geoip_country)
}

// optional bytes session_key = 9;
inline bool LogonResult::has_session_key() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void LogonResult::set_has_session_key() {
  _has_bits_[0] |= 0x00000100u;
}
inline void LogonResult::clear_has_session_key() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void LogonResult::clear_session_key() {
  if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    session_key_->clear();
  }
  clear_has_session_key();
}
inline const ::std::string& LogonResult::session_key() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.session_key)
  return *session_key_;
}
inline void LogonResult::set_session_key(const ::std::string& value) {
  set_has_session_key();
  if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    session_key_ = new ::std::string;
  }
  session_key_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.session_key)
}
inline void LogonResult::set_session_key(const char* value) {
  set_has_session_key();
  if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    session_key_ = new ::std::string;
  }
  session_key_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.LogonResult.session_key)
}
inline void LogonResult::set_session_key(const void* value, size_t size) {
  set_has_session_key();
  if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    session_key_ = new ::std::string;
  }
  session_key_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.LogonResult.session_key)
}
inline ::std::string* LogonResult::mutable_session_key() {
  set_has_session_key();
  if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    session_key_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.LogonResult.session_key)
  return session_key_;
}
inline ::std::string* LogonResult::release_session_key() {
  clear_has_session_key();
  if (session_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = session_key_;
    session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void LogonResult::set_allocated_session_key(::std::string* session_key) {
  if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete session_key_;
  }
  if (session_key) {
    set_has_session_key();
    session_key_ = session_key;
  } else {
    clear_has_session_key();
    session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.LogonResult.session_key)
}

// optional bool restricted_mode = 10;
inline bool LogonResult::has_restricted_mode() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void LogonResult::set_has_restricted_mode() {
  _has_bits_[0] |= 0x00000200u;
}
inline void LogonResult::clear_has_restricted_mode() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void LogonResult::clear_restricted_mode() {
  restricted_mode_ = false;
  clear_has_restricted_mode();
}
inline bool LogonResult::restricted_mode() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonResult.restricted_mode)
  return restricted_mode_;
}
inline void LogonResult::set_restricted_mode(bool value) {
  set_has_restricted_mode();
  restricted_mode_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonResult.restricted_mode)
}

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

// GenerateSSOTokenRequest

// optional fixed32 program = 1;
inline bool GenerateSSOTokenRequest::has_program() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GenerateSSOTokenRequest::set_has_program() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GenerateSSOTokenRequest::clear_has_program() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GenerateSSOTokenRequest::clear_program() {
  program_ = 0u;
  clear_has_program();
}
inline ::google::protobuf::uint32 GenerateSSOTokenRequest::program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenRequest.program)
  return program_;
}
inline void GenerateSSOTokenRequest::set_program(::google::protobuf::uint32 value) {
  set_has_program();
  program_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenRequest.program)
}

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

// GenerateSSOTokenResponse

// optional bytes sso_id = 1;
inline bool GenerateSSOTokenResponse::has_sso_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GenerateSSOTokenResponse::set_has_sso_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GenerateSSOTokenResponse::clear_has_sso_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GenerateSSOTokenResponse::clear_sso_id() {
  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_->clear();
  }
  clear_has_sso_id();
}
inline const ::std::string& GenerateSSOTokenResponse::sso_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
  return *sso_id_;
}
inline void GenerateSSOTokenResponse::set_sso_id(const ::std::string& value) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
}
inline void GenerateSSOTokenResponse::set_sso_id(const char* value) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
}
inline void GenerateSSOTokenResponse::set_sso_id(const void* value, size_t size) {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  sso_id_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
}
inline ::std::string* GenerateSSOTokenResponse::mutable_sso_id() {
  set_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_id_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
  return sso_id_;
}
inline ::std::string* GenerateSSOTokenResponse::release_sso_id() {
  clear_has_sso_id();
  if (sso_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = sso_id_;
    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void GenerateSSOTokenResponse::set_allocated_sso_id(::std::string* sso_id) {
  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete sso_id_;
  }
  if (sso_id) {
    set_has_sso_id();
    sso_id_ = sso_id;
  } else {
    clear_has_sso_id();
    sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_id)
}

// optional bytes sso_secret = 2;
inline bool GenerateSSOTokenResponse::has_sso_secret() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GenerateSSOTokenResponse::set_has_sso_secret() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GenerateSSOTokenResponse::clear_has_sso_secret() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GenerateSSOTokenResponse::clear_sso_secret() {
  if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_secret_->clear();
  }
  clear_has_sso_secret();
}
inline const ::std::string& GenerateSSOTokenResponse::sso_secret() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
  return *sso_secret_;
}
inline void GenerateSSOTokenResponse::set_sso_secret(const ::std::string& value) {
  set_has_sso_secret();
  if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_secret_ = new ::std::string;
  }
  sso_secret_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
}
inline void GenerateSSOTokenResponse::set_sso_secret(const char* value) {
  set_has_sso_secret();
  if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_secret_ = new ::std::string;
  }
  sso_secret_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
}
inline void GenerateSSOTokenResponse::set_sso_secret(const void* value, size_t size) {
  set_has_sso_secret();
  if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_secret_ = new ::std::string;
  }
  sso_secret_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
}
inline ::std::string* GenerateSSOTokenResponse::mutable_sso_secret() {
  set_has_sso_secret();
  if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    sso_secret_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
  return sso_secret_;
}
inline ::std::string* GenerateSSOTokenResponse::release_sso_secret() {
  clear_has_sso_secret();
  if (sso_secret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = sso_secret_;
    sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void GenerateSSOTokenResponse::set_allocated_sso_secret(::std::string* sso_secret) {
  if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete sso_secret_;
  }
  if (sso_secret) {
    set_has_sso_secret();
    sso_secret_ = sso_secret;
  } else {
    clear_has_sso_secret();
    sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateSSOTokenResponse.sso_secret)
}

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

// LogonUpdateRequest

// required uint32 error_code = 1;
inline bool LogonUpdateRequest::has_error_code() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogonUpdateRequest::set_has_error_code() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LogonUpdateRequest::clear_has_error_code() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LogonUpdateRequest::clear_error_code() {
  error_code_ = 0u;
  clear_has_error_code();
}
inline ::google::protobuf::uint32 LogonUpdateRequest::error_code() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonUpdateRequest.error_code)
  return error_code_;
}
inline void LogonUpdateRequest::set_error_code(::google::protobuf::uint32 value) {
  set_has_error_code();
  error_code_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonUpdateRequest.error_code)
}

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

// LogonQueueUpdateRequest

// required uint32 position = 1;
inline bool LogonQueueUpdateRequest::has_position() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LogonQueueUpdateRequest::set_has_position() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LogonQueueUpdateRequest::clear_has_position() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LogonQueueUpdateRequest::clear_position() {
  position_ = 0u;
  clear_has_position();
}
inline ::google::protobuf::uint32 LogonQueueUpdateRequest::position() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.position)
  return position_;
}
inline void LogonQueueUpdateRequest::set_position(::google::protobuf::uint32 value) {
  set_has_position();
  position_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.position)
}

// required uint64 estimated_time = 2;
inline bool LogonQueueUpdateRequest::has_estimated_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LogonQueueUpdateRequest::set_has_estimated_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LogonQueueUpdateRequest::clear_has_estimated_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LogonQueueUpdateRequest::clear_estimated_time() {
  estimated_time_ = GOOGLE_ULONGLONG(0);
  clear_has_estimated_time();
}
inline ::google::protobuf::uint64 LogonQueueUpdateRequest::estimated_time() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.estimated_time)
  return estimated_time_;
}
inline void LogonQueueUpdateRequest::set_estimated_time(::google::protobuf::uint64 value) {
  set_has_estimated_time();
  estimated_time_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.estimated_time)
}

// required uint64 eta_deviation_in_sec = 3;
inline bool LogonQueueUpdateRequest::has_eta_deviation_in_sec() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LogonQueueUpdateRequest::set_has_eta_deviation_in_sec() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LogonQueueUpdateRequest::clear_has_eta_deviation_in_sec() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void LogonQueueUpdateRequest::clear_eta_deviation_in_sec() {
  eta_deviation_in_sec_ = GOOGLE_ULONGLONG(0);
  clear_has_eta_deviation_in_sec();
}
inline ::google::protobuf::uint64 LogonQueueUpdateRequest::eta_deviation_in_sec() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.eta_deviation_in_sec)
  return eta_deviation_in_sec_;
}
inline void LogonQueueUpdateRequest::set_eta_deviation_in_sec(::google::protobuf::uint64 value) {
  set_has_eta_deviation_in_sec();
  eta_deviation_in_sec_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.LogonQueueUpdateRequest.eta_deviation_in_sec)
}

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

// AccountSettingsNotification

// repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
inline int AccountSettingsNotification::licenses_size() const {
  return licenses_.size();
}
inline void AccountSettingsNotification::clear_licenses() {
  licenses_.Clear();
}
inline const ::bgs::protocol::account::v1::AccountLicense& AccountSettingsNotification::licenses(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses)
  return licenses_.Get(index);
}
inline ::bgs::protocol::account::v1::AccountLicense* AccountSettingsNotification::mutable_licenses(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses)
  return licenses_.Mutable(index);
}
inline ::bgs::protocol::account::v1::AccountLicense* AccountSettingsNotification::add_licenses() {
  // @@protoc_insertion_point(field_add:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses)
  return licenses_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
AccountSettingsNotification::licenses() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses)
  return licenses_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
AccountSettingsNotification::mutable_licenses() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.authentication.v1.AccountSettingsNotification.licenses)
  return &licenses_;
}

// optional bool is_using_rid = 2;
inline bool AccountSettingsNotification::has_is_using_rid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccountSettingsNotification::set_has_is_using_rid() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AccountSettingsNotification::clear_has_is_using_rid() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AccountSettingsNotification::clear_is_using_rid() {
  is_using_rid_ = false;
  clear_has_is_using_rid();
}
inline bool AccountSettingsNotification::is_using_rid() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.is_using_rid)
  return is_using_rid_;
}
inline void AccountSettingsNotification::set_is_using_rid(bool value) {
  set_has_is_using_rid();
  is_using_rid_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.is_using_rid)
}

// optional bool is_playing_from_igr = 3;
inline bool AccountSettingsNotification::has_is_playing_from_igr() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AccountSettingsNotification::set_has_is_playing_from_igr() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AccountSettingsNotification::clear_has_is_playing_from_igr() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AccountSettingsNotification::clear_is_playing_from_igr() {
  is_playing_from_igr_ = false;
  clear_has_is_playing_from_igr();
}
inline bool AccountSettingsNotification::is_playing_from_igr() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.is_playing_from_igr)
  return is_playing_from_igr_;
}
inline void AccountSettingsNotification::set_is_playing_from_igr(bool value) {
  set_has_is_playing_from_igr();
  is_playing_from_igr_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.is_playing_from_igr)
}

// optional bool can_receive_voice = 4;
inline bool AccountSettingsNotification::has_can_receive_voice() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AccountSettingsNotification::set_has_can_receive_voice() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AccountSettingsNotification::clear_has_can_receive_voice() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AccountSettingsNotification::clear_can_receive_voice() {
  can_receive_voice_ = false;
  clear_has_can_receive_voice();
}
inline bool AccountSettingsNotification::can_receive_voice() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.AccountSettingsNotification.can_receive_voice)
  return can_receive_voice_;
}
inline void AccountSettingsNotification::set_can_receive_voice(bool value) {
  set_has_can_receive_voice();
  can_receive_voice_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.can_receive_voice)
}

// optional bool can_send_voice = 5;
inline bool AccountSettingsNotification::has_can_send_voice() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AccountSettingsNotification::set_has_can_send_voice() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AccountSettingsNotification::clear_has_can_send_voice() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AccountSettingsNotification::clear_can_send_voice() {
  can_send_voice_ = false;
  clear_has_can_send_voice();
}
inline bool AccountSettingsNotification::can_send_voice() const {
  // @@protoc_insertion_point(field_get:rotocol.authentication.v1.AccountSettingsNotification.can_send_voice)
  return can_send_voice_;
}
inline void AccountSettingsNotification::set_can_send_voice(bool value) {
  set_has_can_send_voice();
  can_send_voice_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.AccountSettingsNotification.can_send_voice)
}

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

// ServerStateChangeRequest

// required uint32 state = 1;
inline bool ServerStateChangeRequest::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ServerStateChangeRequest::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ServerStateChangeRequest::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ServerStateChangeRequest::clear_state() {
  state_ = 0u;
  clear_has_state();
}
inline ::google::protobuf::uint32 ServerStateChangeRequest::state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ServerStateChangeRequest.state)
  return state_;
}
inline void ServerStateChangeRequest::set_state(::google::protobuf::uint32 value) {
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ServerStateChangeRequest.state)
}

// required uint64 event_time = 2;
inline bool ServerStateChangeRequest::has_event_time() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ServerStateChangeRequest::set_has_event_time() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ServerStateChangeRequest::clear_has_event_time() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ServerStateChangeRequest::clear_event_time() {
  event_time_ = GOOGLE_ULONGLONG(0);
  clear_has_event_time();
}
inline ::google::protobuf::uint64 ServerStateChangeRequest::event_time() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.ServerStateChangeRequest.event_time)
  return event_time_;
}
inline void ServerStateChangeRequest::set_event_time(::google::protobuf::uint64 value) {
  set_has_event_time();
  event_time_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.ServerStateChangeRequest.event_time)
}

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

// VersionInfo

// optional uint32 number = 1;
inline bool VersionInfo::has_number() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VersionInfo::set_has_number() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VersionInfo::clear_has_number() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VersionInfo::clear_number() {
  number_ = 0u;
  clear_has_number();
}
inline ::google::protobuf::uint32 VersionInfo::number() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.number)
  return number_;
}
inline void VersionInfo::set_number(::google::protobuf::uint32 value) {
  set_has_number();
  number_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.number)
}

// optional string patch = 2;
inline bool VersionInfo::has_patch() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void VersionInfo::set_has_patch() {
  _has_bits_[0] |= 0x00000002u;
}
inline void VersionInfo::clear_has_patch() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void VersionInfo::clear_patch() {
  if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    patch_->clear();
  }
  clear_has_patch();
}
inline const ::std::string& VersionInfo::patch() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.patch)
  return *patch_;
}
inline void VersionInfo::set_patch(const ::std::string& value) {
  set_has_patch();
  if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    patch_ = new ::std::string;
  }
  patch_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.patch)
}
inline void VersionInfo::set_patch(const char* value) {
  set_has_patch();
  if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    patch_ = new ::std::string;
  }
  patch_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.VersionInfo.patch)
}
inline void VersionInfo::set_patch(const char* value, size_t size) {
  set_has_patch();
  if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    patch_ = new ::std::string;
  }
  patch_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.VersionInfo.patch)
}
inline ::std::string* VersionInfo::mutable_patch() {
  set_has_patch();
  if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    patch_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VersionInfo.patch)
  return patch_;
}
inline ::std::string* VersionInfo::release_patch() {
  clear_has_patch();
  if (patch_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = patch_;
    patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void VersionInfo::set_allocated_patch(::std::string* patch) {
  if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete patch_;
  }
  if (patch) {
    set_has_patch();
    patch_ = patch;
  } else {
    clear_has_patch();
    patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VersionInfo.patch)
}

// optional bool is_optional = 3;
inline bool VersionInfo::has_is_optional() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void VersionInfo::set_has_is_optional() {
  _has_bits_[0] |= 0x00000004u;
}
inline void VersionInfo::clear_has_is_optional() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void VersionInfo::clear_is_optional() {
  is_optional_ = false;
  clear_has_is_optional();
}
inline bool VersionInfo::is_optional() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.is_optional)
  return is_optional_;
}
inline void VersionInfo::set_is_optional(bool value) {
  set_has_is_optional();
  is_optional_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.is_optional)
}

// optional uint64 kick_time = 4;
inline bool VersionInfo::has_kick_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void VersionInfo::set_has_kick_time() {
  _has_bits_[0] |= 0x00000008u;
}
inline void VersionInfo::clear_has_kick_time() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void VersionInfo::clear_kick_time() {
  kick_time_ = GOOGLE_ULONGLONG(0);
  clear_has_kick_time();
}
inline ::google::protobuf::uint64 VersionInfo::kick_time() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfo.kick_time)
  return kick_time_;
}
inline void VersionInfo::set_kick_time(::google::protobuf::uint64 value) {
  set_has_kick_time();
  kick_time_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VersionInfo.kick_time)
}

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

// VersionInfoNotification

// optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
inline bool VersionInfoNotification::has_version_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VersionInfoNotification::set_has_version_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VersionInfoNotification::clear_has_version_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VersionInfoNotification::clear_version_info() {
  if (version_info_ != NULL) version_info_->::bgs::protocol::authentication::v1::VersionInfo::Clear();
  clear_has_version_info();
}
inline const ::bgs::protocol::authentication::v1::VersionInfo& VersionInfoNotification::version_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VersionInfoNotification.version_info)
  return version_info_ != NULL ? *version_info_ : *default_instance_->version_info_;
}
inline ::bgs::protocol::authentication::v1::VersionInfo* VersionInfoNotification::mutable_version_info() {
  set_has_version_info();
  if (version_info_ == NULL) version_info_ = new ::bgs::protocol::authentication::v1::VersionInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VersionInfoNotification.version_info)
  return version_info_;
}
inline ::bgs::protocol::authentication::v1::VersionInfo* VersionInfoNotification::release_version_info() {
  clear_has_version_info();
  ::bgs::protocol::authentication::v1::VersionInfo* temp = version_info_;
  version_info_ = NULL;
  return temp;
}
inline void VersionInfoNotification::set_allocated_version_info(::bgs::protocol::authentication::v1::VersionInfo* version_info) {
  delete version_info_;
  version_info_ = version_info;
  if (version_info) {
    set_has_version_info();
  } else {
    clear_has_version_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VersionInfoNotification.version_info)
}

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

// MemModuleLoadRequest

// required .bgs.protocol.ContentHandle handle = 1;
inline bool MemModuleLoadRequest::has_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MemModuleLoadRequest::set_has_handle() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MemModuleLoadRequest::clear_has_handle() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MemModuleLoadRequest::clear_handle() {
  if (handle_ != NULL) handle_->::bgs::protocol::ContentHandle::Clear();
  clear_has_handle();
}
inline const ::bgs::protocol::ContentHandle& MemModuleLoadRequest::handle() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle)
  return handle_ != NULL ? *handle_ : *default_instance_->handle_;
}
inline ::bgs::protocol::ContentHandle* MemModuleLoadRequest::mutable_handle() {
  set_has_handle();
  if (handle_ == NULL) handle_ = new ::bgs::protocol::ContentHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle)
  return handle_;
}
inline ::bgs::protocol::ContentHandle* MemModuleLoadRequest::release_handle() {
  clear_has_handle();
  ::bgs::protocol::ContentHandle* temp = handle_;
  handle_ = NULL;
  return temp;
}
inline void MemModuleLoadRequest::set_allocated_handle(::bgs::protocol::ContentHandle* handle) {
  delete handle_;
  handle_ = handle;
  if (handle) {
    set_has_handle();
  } else {
    clear_has_handle();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.handle)
}

// required bytes key = 2;
inline bool MemModuleLoadRequest::has_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void MemModuleLoadRequest::set_has_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void MemModuleLoadRequest::clear_has_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void MemModuleLoadRequest::clear_key() {
  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    key_->clear();
  }
  clear_has_key();
}
inline const ::std::string& MemModuleLoadRequest::key() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
  return *key_;
}
inline void MemModuleLoadRequest::set_key(const ::std::string& value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    key_ = new ::std::string;
  }
  key_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
}
inline void MemModuleLoadRequest::set_key(const char* value) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    key_ = new ::std::string;
  }
  key_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
}
inline void MemModuleLoadRequest::set_key(const void* value, size_t size) {
  set_has_key();
  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    key_ = new ::std::string;
  }
  key_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
}
inline ::std::string* MemModuleLoadRequest::mutable_key() {
  set_has_key();
  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    key_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
  return key_;
}
inline ::std::string* MemModuleLoadRequest::release_key() {
  clear_has_key();
  if (key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = key_;
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void MemModuleLoadRequest::set_allocated_key(::std::string* key) {
  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete key_;
  }
  if (key) {
    set_has_key();
    key_ = key;
  } else {
    clear_has_key();
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.key)
}

// required bytes input = 3;
inline bool MemModuleLoadRequest::has_input() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MemModuleLoadRequest::set_has_input() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MemModuleLoadRequest::clear_has_input() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MemModuleLoadRequest::clear_input() {
  if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    input_->clear();
  }
  clear_has_input();
}
inline const ::std::string& MemModuleLoadRequest::input() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
  return *input_;
}
inline void MemModuleLoadRequest::set_input(const ::std::string& value) {
  set_has_input();
  if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    input_ = new ::std::string;
  }
  input_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
}
inline void MemModuleLoadRequest::set_input(const char* value) {
  set_has_input();
  if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    input_ = new ::std::string;
  }
  input_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
}
inline void MemModuleLoadRequest::set_input(const void* value, size_t size) {
  set_has_input();
  if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    input_ = new ::std::string;
  }
  input_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
}
inline ::std::string* MemModuleLoadRequest::mutable_input() {
  set_has_input();
  if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    input_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
  return input_;
}
inline ::std::string* MemModuleLoadRequest::release_input() {
  clear_has_input();
  if (input_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = input_;
    input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void MemModuleLoadRequest::set_allocated_input(::std::string* input) {
  if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete input_;
  }
  if (input) {
    set_has_input();
    input_ = input;
  } else {
    clear_has_input();
    input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadRequest.input)
}

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

// MemModuleLoadResponse

// required bytes data = 1;
inline bool MemModuleLoadResponse::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MemModuleLoadResponse::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MemModuleLoadResponse::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MemModuleLoadResponse::clear_data() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    data_->clear();
  }
  clear_has_data();
}
inline const ::std::string& MemModuleLoadResponse::data() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
  return *data_;
}
inline void MemModuleLoadResponse::set_data(const ::std::string& value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    data_ = new ::std::string;
  }
  data_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
}
inline void MemModuleLoadResponse::set_data(const char* value) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    data_ = new ::std::string;
  }
  data_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
}
inline void MemModuleLoadResponse::set_data(const void* value, size_t size) {
  set_has_data();
  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    data_ = new ::std::string;
  }
  data_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
}
inline ::std::string* MemModuleLoadResponse::mutable_data() {
  set_has_data();
  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    data_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
  return data_;
}
inline ::std::string* MemModuleLoadResponse::release_data() {
  clear_has_data();
  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = data_;
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void MemModuleLoadResponse::set_allocated_data(::std::string* data) {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (data) {
    set_has_data();
    data_ = data;
  } else {
    clear_has_data();
    data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.MemModuleLoadResponse.data)
}

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

// SelectGameAccountRequest

// required .bgs.protocol.EntityId game_account_id = 1;
inline bool SelectGameAccountRequest::has_game_account_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SelectGameAccountRequest::set_has_game_account_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SelectGameAccountRequest::clear_has_game_account_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SelectGameAccountRequest::clear_game_account_id() {
  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_game_account_id();
}
inline const ::bgs::protocol::EntityId& SelectGameAccountRequest::game_account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id)
  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
}
inline ::bgs::protocol::EntityId* SelectGameAccountRequest::mutable_game_account_id() {
  set_has_game_account_id();
  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id)
  return game_account_id_;
}
inline ::bgs::protocol::EntityId* SelectGameAccountRequest::release_game_account_id() {
  clear_has_game_account_id();
  ::bgs::protocol::EntityId* temp = game_account_id_;
  game_account_id_ = NULL;
  return temp;
}
inline void SelectGameAccountRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
  delete game_account_id_;
  game_account_id_ = game_account_id;
  if (game_account_id) {
    set_has_game_account_id();
  } else {
    clear_has_game_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.SelectGameAccountRequest.game_account_id)
}

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

// GameAccountSelectedRequest

// required uint32 result = 1;
inline bool GameAccountSelectedRequest::has_result() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameAccountSelectedRequest::set_has_result() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameAccountSelectedRequest::clear_has_result() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameAccountSelectedRequest::clear_result() {
  result_ = 0u;
  clear_has_result();
}
inline ::google::protobuf::uint32 GameAccountSelectedRequest::result() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GameAccountSelectedRequest.result)
  return result_;
}
inline void GameAccountSelectedRequest::set_result(::google::protobuf::uint32 value) {
  set_has_result();
  result_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GameAccountSelectedRequest.result)
}

// optional .bgs.protocol.EntityId game_account_id = 2;
inline bool GameAccountSelectedRequest::has_game_account_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameAccountSelectedRequest::set_has_game_account_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameAccountSelectedRequest::clear_has_game_account_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameAccountSelectedRequest::clear_game_account_id() {
  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_game_account_id();
}
inline const ::bgs::protocol::EntityId& GameAccountSelectedRequest::game_account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id)
  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
}
inline ::bgs::protocol::EntityId* GameAccountSelectedRequest::mutable_game_account_id() {
  set_has_game_account_id();
  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id)
  return game_account_id_;
}
inline ::bgs::protocol::EntityId* GameAccountSelectedRequest::release_game_account_id() {
  clear_has_game_account_id();
  ::bgs::protocol::EntityId* temp = game_account_id_;
  game_account_id_ = NULL;
  return temp;
}
inline void GameAccountSelectedRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
  delete game_account_id_;
  game_account_id_ = game_account_id;
  if (game_account_id) {
    set_has_game_account_id();
  } else {
    clear_has_game_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GameAccountSelectedRequest.game_account_id)
}

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

// GenerateWebCredentialsRequest

// optional fixed32 program = 1;
inline bool GenerateWebCredentialsRequest::has_program() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GenerateWebCredentialsRequest::set_has_program() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GenerateWebCredentialsRequest::clear_has_program() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GenerateWebCredentialsRequest::clear_program() {
  program_ = 0u;
  clear_has_program();
}
inline ::google::protobuf::uint32 GenerateWebCredentialsRequest::program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest.program)
  return program_;
}
inline void GenerateWebCredentialsRequest::set_program(::google::protobuf::uint32 value) {
  set_has_program();
  program_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest.program)
}

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

// GenerateWebCredentialsResponse

// optional bytes web_credentials = 1;
inline bool GenerateWebCredentialsResponse::has_web_credentials() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GenerateWebCredentialsResponse::set_has_web_credentials() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GenerateWebCredentialsResponse::clear_has_web_credentials() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GenerateWebCredentialsResponse::clear_web_credentials() {
  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_->clear();
  }
  clear_has_web_credentials();
}
inline const ::std::string& GenerateWebCredentialsResponse::web_credentials() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
  return *web_credentials_;
}
inline void GenerateWebCredentialsResponse::set_web_credentials(const ::std::string& value) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
}
inline void GenerateWebCredentialsResponse::set_web_credentials(const char* value) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
}
inline void GenerateWebCredentialsResponse::set_web_credentials(const void* value, size_t size) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
}
inline ::std::string* GenerateWebCredentialsResponse::mutable_web_credentials() {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
  return web_credentials_;
}
inline ::std::string* GenerateWebCredentialsResponse::release_web_credentials() {
  clear_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = web_credentials_;
    web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void GenerateWebCredentialsResponse::set_allocated_web_credentials(::std::string* web_credentials) {
  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete web_credentials_;
  }
  if (web_credentials) {
    set_has_web_credentials();
    web_credentials_ = web_credentials;
  } else {
    clear_has_web_credentials();
    web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse.web_credentials)
}

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

// VerifyWebCredentialsRequest

// optional bytes web_credentials = 1;
inline bool VerifyWebCredentialsRequest::has_web_credentials() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void VerifyWebCredentialsRequest::set_has_web_credentials() {
  _has_bits_[0] |= 0x00000001u;
}
inline void VerifyWebCredentialsRequest::clear_has_web_credentials() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void VerifyWebCredentialsRequest::clear_web_credentials() {
  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_->clear();
  }
  clear_has_web_credentials();
}
inline const ::std::string& VerifyWebCredentialsRequest::web_credentials() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
  return *web_credentials_;
}
inline void VerifyWebCredentialsRequest::set_web_credentials(const ::std::string& value) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
}
inline void VerifyWebCredentialsRequest::set_web_credentials(const char* value) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
}
inline void VerifyWebCredentialsRequest::set_web_credentials(const void* value, size_t size) {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  web_credentials_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
}
inline ::std::string* VerifyWebCredentialsRequest::mutable_web_credentials() {
  set_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    web_credentials_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
  return web_credentials_;
}
inline ::std::string* VerifyWebCredentialsRequest::release_web_credentials() {
  clear_has_web_credentials();
  if (web_credentials_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = web_credentials_;
    web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void VerifyWebCredentialsRequest::set_allocated_web_credentials(::std::string* web_credentials) {
  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete web_credentials_;
  }
  if (web_credentials) {
    set_has_web_credentials();
    web_credentials_ = web_credentials;
  } else {
    clear_has_web_credentials();
    web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest.web_credentials)
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace authentication
}  // namespace protocol
}  // namespace bgs

#ifndef SWIG
namespace google {
namespace protobuf {


}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_authentication_5fservice_2eproto__INCLUDED